3900. Longest Balanced Substring After One Swap

MediumHash TableStringPrefix Sum

LeetCode ↗

Problem Pattern Idea Example Code Complex Pitfalls

Problem Description

You are given a binary string s consisting only of the characters '0' and '1'.

A string is called balanced if it contains an equal number of '0's and '1's.

You are allowed to perform at most one swap between any two characters in s. A swap means picking two positions in the string and exchanging the characters located there. After performing this optional swap, you then select a balanced substring from s.

Your task is to return an integer representing the maximum length of the balanced substring you can select.

A few key points to keep in mind:

The swap is optional, meaning you may choose to perform zero swaps or exactly one swap, whichever yields a longer balanced substring.
A substring is a contiguous, non-empty sequence of characters within the string.
Since a balanced substring must contain an equal number of '0's and '1's, its length is always an even number.
If no balanced substring can be formed, the answer is 0.

For example, consider a substring that has exactly 2 more '1's than '0's. A single swap can fix this imbalance only if there is still at least one '0' available somewhere outside this substring, allowing you to swap one of the extra '1's out for a '0'. The symmetric situation applies when a substring has 2 more '0's than '1's and a '1' exists outside of it.

Quick Interview Experience

Help others by sharing your interview experience

Have you seen this problem before?

How We Pick the Algorithm

Why Hash Table / Counting?

This problem maps to Hash Table / Counting through a short path in the full flowchart.

Using a hash map for constant-time frequency counting enables the solution.

Open in Flowchart

Intuition

The first natural question is: how do we quickly tell whether a substring is balanced? A classic trick for counting problems on substrings is the prefix sum. Here, instead of summing raw values, we treat every '1' as +1 and every '0' as -1, and accumulate these as we scan the string. Call this running total pre.

With this encoding, the value pre[j] - pre[i] equals the number of '1's minus the number of '0's in the substring from position i + 1 to j. A substring is balanced exactly when this difference is 0, which means pre[j] == pre[i]. So two positions sharing the same prefix sum bound a balanced substring. To maximize length, for each prefix value we only care about its earliest occurrence, since pairing the current index with the earliest matching index gives the longest possible span.

Now we bring in the twist: we are allowed at most one swap. The crucial observation is understanding what one swap can do to a substring's balance. Swapping a '1' inside the substring with a '0' outside it changes the inside count by +1 '0' and -1 '1', shifting the difference by exactly 2. So one swap can correct an imbalance of magnitude 2, and nothing more.

This means, beyond the perfectly balanced case (pre difference 0), we should also examine substrings whose prefix sum difference is +2 or -2:

A difference of +2 means the substring has 2 extra '1's. We can fix it by swapping one of those extra '1's with a '0' from outside the substring — but only if such an outside '0' actually exists.
A difference of -2 is the mirror image: 2 extra '0's, fixable only if a '1' exists outside.

How do we check whether a usable character exists outside? Count the total '0's (cnt0) and total '1's (cnt1) in the whole string up front. For a candidate substring of length L with 2 extra '1's, the number of '0's inside it is (L - 2) / 2. If this is strictly less than cnt0, then at least one '0' lives outside the substring and the swap is feasible. The '1'-based case is symmetric, comparing against cnt1.

There is one subtle edge case. We always prefer the earliest occurrence of the needed prefix value to get the longest substring. But that longest candidate might use up all the '0's (or '1's), leaving nothing outside to swap. When that happens, we fall back to the second earliest occurrence, which gives a slightly shorter substring but frees up a character outside, making the swap valid again. That is exactly why the hash table stores a list of positions for each prefix value rather than just the first one.

Putting it together: scan once, maintain the prefix sum, record positions of each prefix value, and at every step update the answer using the matching prefixes pre, pre - 2, and pre + 2, applying the outside-character feasibility check for the swap cases. This yields the maximum balanced length in a single linear pass.

Pattern Learn more about Prefix Sum patterns.

Solution Approach

We use Prefix Sum + Hash Table to solve this in a single linear scan.

Step 1: Count the total characters.

First, compute the total number of '0's and '1's in the whole string:

cnt0 = s.count("0")
cnt1 = len(s) - cnt0

These two values let us later check whether a character is still available outside a candidate substring for swapping.

Step 2: Set up the prefix sum and hash table.

We maintain a running prefix sum pre, treating '1' as +1 and '0' as -1. We use a hash table pos that maps each prefix value to the list of indices where that value appears, in increasing order. We seed it with {0: [-1]} so that a balanced substring starting from index 0 is handled correctly (the prefix sum before the string begins is 0 at the virtual position -1).

pos = {0: [-1]}
ans = pre = 0

Step 3: Scan the string and update the answer.

For each index i with character c, we update pre, then append i to the list for the current prefix value:

pre += 1 if c == "1" else -1
pos.setdefault(pre, []).append(i)

Now we consider three cases to update ans.

Case 0 — no swap needed (pre matches): Since the current index was just appended, pos[pre][0] is the earliest position holding this prefix value. The substring between them has difference 0, so it is already balanced:
```
ans = max(ans, i - pos[pre][0])
```
Case 1 — substring with 2 extra '1's (pre - 2 exists): Pairing the current index with a position of prefix pre - 2 gives a substring whose '1' count exceeds its '0' count by 2. We first try the earliest such position p[0] for the longest length. The number of '0's inside this substring is (i - p[0] - 2) // 2. If this is strictly less than cnt0, a '0' exists outside and the swap works:
```
if pre - 2 in pos:
    p = pos[pre - 2]
    if (i - p[0] - 2) // 2 < cnt0:
        ans = max(ans, i - p[0])
    elif len(p) > 1:
        ans = max(ans, i - p[1])
```
If the earliest position uses up all the '0's, we fall back to the second earliest position p[1] (when it exists), which is a shorter substring that leaves a '0' outside.

Case 2 — substring with 2 extra '0's (pre + 2 exists): This is the mirror image. We need a '1' outside, so we compare the inside '1' count (i - p[0] - 2) // 2 against cnt1:

if pre + 2 in pos:
    p = pos[pre + 2]
    if (i - p[0] - 2) // 2 < cnt1:
        ans = max(ans, i - p[0])
    elif len(p) > 1:
        ans = max(ans, i - p[1])

Step 4: Return the result.

After the scan completes, ans holds the maximum length of a balanced substring obtainable with at most one swap:

return ans

Why storing position lists matters. For the no-swap case we only ever need the earliest index, but for the swap cases the longest candidate might consume every available '0' (or '1'), leaving no character outside. Keeping the first two occurrences of each prefix value lets us gracefully fall back to a slightly shorter—but valid—substring.

Complexity Analysis.

Time complexity: O(n), where n is the length of s. We scan the string once, and every hash table operation is O(1) on average.
Space complexity: O(n), for the hash table storing prefix-sum positions.

Example Walkthrough

Let's trace through the solution with the small input s = "1101".

Step 1: Count total characters.

cnt0 = s.count("0") = 1
cnt1 = len(s) - cnt0 = 4 - 1 = 3

So there is one '0' and three '1's in the whole string. These counts tell us how many of each character are available for an outside swap.

Step 2: Initialize.

pos = {0: [-1]} (virtual position -1 for the empty prefix)
ans = 0, pre = 0

We treat '1' as +1 and '0' as -1.

Step 3: Scan the string.

Let's index the string:

i	0	1	2	3
c	`1`	`1`	`0`	`1`

i = 0, c = '1':

pre += 1 → pre = 1
Append 0 to pos[1] → pos = {0: [-1], 1: [0]}
Case 0 (pre = 1 matched): pos[1][0] = 0, so ans = max(0, 0 - 0) = 0
Case 1 (pre - 2 = -1): not in pos, skip
Case 2 (pre + 2 = 3): not in pos, skip

ans = 0

i = 1, c = '1':

pre += 1 → pre = 2
Append 1 to pos[2] → pos = {0: [-1], 1: [0], 2: [1]}
Case 0 (pre = 2): pos[2][0] = 1, so ans = max(0, 1 - 1) = 0
Case 1 (pre - 2 = 0): exists, p = pos[0] = [-1]
- Inside '0' count = (1 - (-1) - 2) // 2 = 0. Is 0 < cnt0 = 1? Yes.
- Substring is s[0..1] = "11" (2 extra '1's). A '0' exists outside (at index 2), so one swap balances it.
- ans = max(0, 1 - (-1)) = 2
Case 2 (pre + 2 = 4): not in pos, skip

ans = 2

i = 2, c = '0':

pre += -1 → pre = 1
Append 2 to pos[1] → pos = {0: [-1], 1: [0, 2], 2: [1]}
Case 0 (pre = 1): pos[1][0] = 0, so ans = max(2, 2 - 0) = 2
- Substring s[1..2] = "10" is already balanced (length 2), no swap needed.
Case 1 (pre - 2 = -1): not in pos, skip
Case 2 (pre + 2 = 3): not in pos, skip

ans = 2

i = 3, c = '1':

pre += 1 → pre = 2
Append 3 to pos[2] → pos = {0: [-1], 1: [0, 2], 2: [1, 3]}
Case 0 (pre = 2): pos[2][0] = 1, so ans = max(2, 3 - 1) = 2
- Substring s[2..3] = "01" already balanced (length 2).
Case 1 (pre - 2 = 0): exists, p = pos[0] = [-1]
- Inside '0' count = (3 - (-1) - 2) // 2 = 1. Is 1 < cnt0 = 1? No.
- The candidate substring s[0..3] = "1101" (length 4) contains 2 extra '1's, but it uses up the only '0' available — none left outside to swap.
- Fallback: len(p) > 1? p = [-1] has length 1, so no second position exists. Skip.
Case 2 (pre + 2 = 4): not in pos, skip

ans = 2

Step 4: Return.

The scan completes with ans = 2.

Result: The maximum length of a balanced substring obtainable with at most one swap is 2.

This example highlights the key edge case: at i = 3, the longest candidate ("1101", length 4) seemed promising, but it consumed the only '0' in the string, leaving nothing outside to swap with. Because there was no second occurrence of prefix value 0 to fall back to, that candidate was correctly rejected — demonstrating exactly why the outside-character feasibility check and the position-list fallback are essential.

Solution Implementation

1class Solution:
2    def longestBalanced(self, s: str) -> int:
3        # Count total zeros and ones in the string.
4        count_zero = s.count("0")
5        count_one = len(s) - count_zero
6
7        # Map each prefix-balance value to the list of indices where it occurs.
8        # Treat '1' as +1 and '0' as -1; balance starts at 0 before index 0.
9        prefix_positions: dict[int, list[int]] = {0: [-1]}
10
11        ans = 0          # Length of the longest balanced substring found so far.
12        prefix = 0       # Running prefix balance.
13
14        for i, ch in enumerate(s):
15            # Update running balance: +1 for '1', -1 for '0'.
16            prefix += 1 if ch == "1" else -1
17            # Record the current index under its prefix-balance value.
18            prefix_positions.setdefault(prefix, []).append(i)
19
20            # Equal prefix values mark a substring with equal zeros and ones.
21            # The earliest occurrence gives the widest such window.
22            ans = max(ans, i - prefix_positions[prefix][0])
23
24            # Case: a prior prefix value smaller by 2 means the in-between
25            # window has one extra '0'; we may convert/use an additional '0'.
26            if prefix - 2 in prefix_positions:
27                positions = prefix_positions[prefix - 2]
28                # Check whether the number of zeros needed stays within budget.
29                if (i - positions[0] - 2) // 2 < count_zero:
30                    ans = max(ans, i - positions[0])
31                elif len(positions) > 1:
32                    # Otherwise fall back to the second-earliest position.
33                    ans = max(ans, i - positions[1])
34
35            # Case: a prior prefix value larger by 2 means the in-between
36            # window has one extra '1'; we may convert/use an additional '1'.
37            if prefix + 2 in prefix_positions:
38                positions = prefix_positions[prefix + 2]
39                # Check whether the number of ones needed stays within budget.
40                if (i - positions[0] - 2) // 2 < count_one:
41                    ans = max(ans, i - positions[0])
42                elif len(positions) > 1:
43                    # Otherwise fall back to the second-earliest position.
44                    ans = max(ans, i - positions[1])
45
46        return ans
47

1import java.util.ArrayList;
2import java.util.HashMap;
3import java.util.List;
4import java.util.Map;
5
6class Solution {
7    public int longestBalanced(String s) {
8        int n = s.length();
9
10        // Count the total number of '0's in the string.
11        int countZero = 0;
12        for (int i = 0; i < n; ++i) {
13            if (s.charAt(i) == '0') {
14                ++countZero;
15            }
16        }
17        // The remaining characters are '1's.
18        int countOne = n - countZero;
19
20        // Map each prefix-sum value to the list of indices where it occurs.
21        // Using '1' -> +1 and '0' -> -1 as the running weight.
22        // We seed the map with prefix-sum 0 at index -1 (empty prefix).
23        Map<Integer, List<Integer>> positions = new HashMap<>();
24        positions.put(0, new ArrayList<>(List.of(-1)));
25
26        int ans = 0;
27        int prefix = 0;
28
29        for (int i = 0; i < n; ++i) {
30            // Update the running prefix sum.
31            prefix += s.charAt(i) == '1' ? 1 : -1;
32
33            // Record the current index for this prefix-sum value.
34            positions.computeIfAbsent(prefix, k -> new ArrayList<>()).add(i);
35
36            // Case 1: same prefix sum found earlier means a balanced substring.
37            // Use the earliest occurrence to maximize length.
38            ans = Math.max(ans, i - positions.get(prefix).get(0));
39
40            // Case 2: prefix difference of 2 (one extra '1' in between).
41            // We may trim that single extra character if counts allow.
42            if (positions.containsKey(prefix - 2)) {
43                List<Integer> previous = positions.get(prefix - 2);
44                // Check whether the balanced part fits within the available '0' count.
45                if ((i - previous.get(0) - 2) / 2 < countZero) {
46                    ans = Math.max(ans, i - previous.get(0));
47                } else if (previous.size() > 1) {
48                    // Otherwise fall back to the second earliest occurrence.
49                    ans = Math.max(ans, i - previous.get(1));
50                }
51            }
52
53            // Case 3: prefix difference of -2 (one extra '0' in between).
54            // Symmetric handling against the available '1' count.
55            if (positions.containsKey(prefix + 2)) {
56                List<Integer> previous = positions.get(prefix + 2);
57                if ((i - previous.get(0) - 2) / 2 < countOne) {
58                    ans = Math.max(ans, i - previous.get(0));
59                } else if (previous.size() > 1) {
60                    ans = Math.max(ans, i - previous.get(1));
61                }
62            }
63        }
64
65        return ans;
66    }
67}
68

1class Solution {
2public:
3    int longestBalanced(string s) {
4        // Total number of '0' and '1' characters in the string.
5        int zeroCount = count(s.begin(), s.end(), '0');
6        int oneCount = static_cast<int>(s.size()) - zeroCount;
7
8        // Map from a prefix-balance value to the list of indices where it occurs.
9        // Balance is incremented for '1' and decremented for '0'.
10        unordered_map<int, vector<int>> balanceToIndices;
11        balanceToIndices[0] = {-1}; // Sentinel: balance is 0 before any character.
12
13        int answer = 0;     // Length of the longest balanced substring found so far.
14        int prefixBalance = 0; // Running prefix balance.
15
16        for (int i = 0; i < static_cast<int>(s.size()); ++i) {
17            // Update the running balance: '1' -> +1, '0' -> -1.
18            prefixBalance += (s[i] == '1') ? 1 : -1;
19            balanceToIndices[prefixBalance].push_back(i);
20
21            // Same balance at the first occurrence and index i means the substring
22            // between them has equal numbers of '0' and '1'.
23            answer = max(answer, i - balanceToIndices[prefixBalance][0]);
24
25            // Consider a segment whose balance differs by -2 (two extra '0's overall).
26            if (balanceToIndices.contains(prefixBalance - 2)) {
27                auto& indices = balanceToIndices[prefixBalance - 2];
28                // If the number of '0's needed for the segment stays within the total
29                // available '0' count, the earliest index can be used directly.
30                if ((i - indices[0] - 2) / 2 < zeroCount) {
31                    answer = max(answer, i - indices[0]);
32                } else if (indices.size() > 1) {
33                    // Otherwise fall back to the second-earliest index.
34                    answer = max(answer, i - indices[1]);
35                }
36            }
37
38            // Consider a segment whose balance differs by +2 (two extra '1's overall).
39            if (balanceToIndices.contains(prefixBalance + 2)) {
40                auto& indices = balanceToIndices[prefixBalance + 2];
41                // If the number of '1's needed for the segment stays within the total
42                // available '1' count, the earliest index can be used directly.
43                if ((i - indices[0] - 2) / 2 < oneCount) {
44                    answer = max(answer, i - indices[0]);
45                } else if (indices.size() > 1) {
46                    // Otherwise fall back to the second-earliest index.
47                    answer = max(answer, i - indices[1]);
48                }
49            }
50        }
51
52        return answer;
53    }
54};
55

1/**
2 * Finds the length of the longest "balanced" substring based on prefix-sum
3 * matching, with additional handling for adjacent prefix-sum values (±2)
4 * bounded by the total counts of '0' and '1' characters.
5 *
6 * @param s - The input binary string consisting of '0' and '1' characters.
7 * @returns The length of the longest qualifying substring.
8 */
9function longestBalanced(s: string): number {
10    // Total number of '0' characters in the string.
11    const zeroCount: number = [...s].filter((char) => char === '0').length;
12    // Total number of '1' characters (derived from total length minus zeros).
13    const oneCount: number = s.length - zeroCount;
14
15    // Maps a prefix-sum value to the list of indices where it first appeared
16    // (and the next occurrence). Index -1 represents the virtual position
17    // before the string starts, anchoring the prefix sum of 0.
18    const prefixPositions: Map<number, number[]> = new Map<number, number[]>();
19    prefixPositions.set(0, [-1]);
20
21    // Stores the maximum length found so far.
22    let maxLength: number = 0;
23    // Running prefix sum: +1 for '1', -1 for '0'.
24    let prefixSum: number = 0;
25
26    for (let i = 0; i < s.length; ++i) {
27        // Update the running prefix sum based on the current character.
28        prefixSum += s[i] === '1' ? 1 : -1;
29
30        // Ensure an entry exists for the current prefix-sum value.
31        if (!prefixPositions.has(prefixSum)) {
32            prefixPositions.set(prefixSum, []);
33        }
34        prefixPositions.get(prefixSum)!.push(i);
35
36        // Equal prefix sums imply a balanced substring; compare with earliest index.
37        maxLength = Math.max(maxLength, i - prefixPositions.get(prefixSum)![0]);
38
39        // Check the neighbor with prefix sum two less (extra '0' imbalance case).
40        if (prefixPositions.has(prefixSum - 2)) {
41            const positions: number[] = prefixPositions.get(prefixSum - 2)!;
42            // If the implied number of zeros stays within the available zero count,
43            // the substring from the earliest index is valid.
44            if ((i - positions[0] - 2) >> 1 < zeroCount) {
45                maxLength = Math.max(maxLength, i - positions[0]);
46            } else if (positions.length > 1) {
47                // Otherwise, fall back to the second recorded index.
48                maxLength = Math.max(maxLength, i - positions[1]);
49            }
50        }
51
52        // Check the neighbor with prefix sum two more (extra '1' imbalance case).
53        if (prefixPositions.has(prefixSum + 2)) {
54            const positions: number[] = prefixPositions.get(prefixSum + 2)!;
55            // If the implied number of ones stays within the available one count,
56            // the substring from the earliest index is valid.
57            if ((i - positions[0] - 2) >> 1 < oneCount) {
58                maxLength = Math.max(maxLength, i - positions[0]);
59            } else if (positions.length > 1) {
60                // Otherwise, fall back to the second recorded index.
61                maxLength = Math.max(maxLength, i - positions[1]);
62            }
63        }
64    }
65
66    return maxLength;
67}
68

Time and Space Complexity

Time Complexity

The overall time complexity is O(n), where n is the length of the string s.

The analysis proceeds as follows:

The initial s.count("0") operation traverses the entire string once, taking O(n) time.
The main for loop iterates over each character of s exactly once, performing n iterations.
Inside the loop, each operation runs in constant time:
- Updating the prefix sum pre is O(1).
- pos.setdefault(pre, []).append(i) performs a dictionary lookup/insertion and a list append, both amortized O(1).
- Accessing pos[pre][0] retrieves the first element of a list, which is O(1).
- The checks for pre - 2 and pre + 2 involve constant-time dictionary lookups and index accesses like p[0] and p[1], each O(1).

Since each of the n iterations performs only constant-time work, the loop contributes O(n). Combined with the initial counting pass, the total time complexity is O(n).

Space Complexity

The space complexity is O(n), where n is the length of the string s.

The dominant space usage comes from the pos dictionary, which maps each distinct prefix-sum value to a list of indices. Across all keys, the total number of stored indices equals the number of loop iterations, which is n. Therefore, the dictionary holds at most O(n) index entries in total. The remaining variables (cnt0, cnt1, ans, pre, etc.) use only O(1) additional space. Hence, the overall space complexity is O(n).

Pattern Learn more about how to find time and space complexity quickly.

Common Pitfalls

Pitfall: Forgetting that a swap is only useful when the extra character exists outside the candidate substring

The most common mistake is to treat any substring with an imbalance of exactly 2 as fixable by a single swap. The reasoning goes: "the substring has 2 extra '1's, so I just swap one of them for a '0' and it becomes balanced." This silently overcounts when the substring already contains every '0' in the entire string—there is no '0' left outside to swap in.

Buggy version (omits the availability check):

# WRONG: blindly accepts any imbalance-2 window as swappable
if prefix - 2 in prefix_positions:
    positions = prefix_positions[prefix - 2]
    ans = max(ans, i - positions[0])   # ignores whether a '0' exists outside

if prefix + 2 in prefix_positions:
    positions = prefix_positions[prefix + 2]
    ans = max(ans, i - positions[0])   # ignores whether a '1' exists outside

Concrete failing case: consider s = "111".

The whole string "111" has 3 ones, 0 zeros — imbalance is 3, not 2, so it is never a candidate. Good.
But take s = "1110". The window "111" (indices 0..2) has 2 extra '1's. The buggy code would happily report length 3... but length must be even, and more importantly the swap-fix logic reasons about converting it to a balanced window of the same length, which is impossible (odd length). The real trap appears with windows like s = "11110": the window "1111" (4 ones, imbalance 4) is skipped, but a window such as the full prefix where all zeros are already inside the window gets wrongly accepted.

A cleaner failing example: s = "0011" reversed reasoning — take any maximal window that swallows the only outside character. Without the budget check, the code claims a swap is possible even though no spare '0'/'1' remains, producing an answer larger than the true maximum.

Why the fix works

A window with 2 extra '1's contains k zeros where:

k = (length - 2) // 2 = (i - positions[0] - 2) // 2

The swap is legal only if at least one '0' lies outside the window, i.e. k < count_zero. The symmetric condition k < count_one guards the 2-extra-'0' case.

The Solution

Always gate the swap on the availability check, and fall back to the second-earliest position when the widest window consumes the entire supply:

if prefix - 2 in prefix_positions:
    positions = prefix_positions[prefix - 2]
    if (i - positions[0] - 2) // 2 < count_zero:   # a '0' remains outside
        ans = max(ans, i - positions[0])
    elif len(positions) > 1:                       # shrink to leave a '0' out
        ans = max(ans, i - positions[1])

if prefix + 2 in prefix_positions:
    positions = prefix_positions[prefix + 2]
    if (i - positions[0] - 2) // 2 < count_one:    # a '1' remains outside
        ans = max(ans, i - positions[0])
    elif len(positions) > 1:                       # shrink to leave a '1' out
        ans = max(ans, i - positions[1])

Related sub-pitfall: storing only the earliest index

If you store only the first occurrence of each prefix value (e.g. if prefix not in pos: pos[prefix] = i), the no-swap case still works, but the fallback in the elif branch becomes impossible—you have no "second-earliest" position to shrink to. This causes the algorithm to miss valid shorter windows that would still leave a spare character outside. Keeping at least the first two occurrences per prefix value is essential for correctness, and costs only O(n) space overall.

Ready to land your dream job?

Unlock your dream job with a 5-minute quiz for a personalized study roadmap!

Get My Roadmap

Discover Your Strengths and Weaknesses: Take Our 5-Minute Quiz to Get a Personalized Study Roadmap:

Which of these properties could exist for a graph but not a tree?

Contain cycles

There are multiple ways to traverse

Connected

Has no cycle

I don't know

3900. Longest Balanced Substring After One Swap

Problem Description

How We Pick the Algorithm

Why Hash Table / Counting?

Intuition

Solution Approach

Example Walkthrough

Solution Implementation

Time and Space Complexity

Time Complexity

Space Complexity

Common Pitfalls

Pitfall: Forgetting that a swap is only useful when the extra character exists outside the candidate substring

Why the fix works

The Solution

Related sub-pitfall: storing only the earliest index

Ready to land your dream job?

Unlock your dream job with a 5-minute quiz for a personalized study roadmap!

Recommended Readings