First Bad Version - Practice Coding Problems

First Bad Version - Problem

You're a product manager leading a software development team, and your latest product release has failed quality assurance! 😱

Here's the challenge: your team develops software versions sequentially [1, 2, 3, ..., n], where each version builds upon the previous one. Unfortunately, once a bad version is introduced, all subsequent versions inherit the same issues and become bad too.

Your mission: Find the first bad version that started this cascade of problems!

🔧 Available Tool: You have access to an API function isBadVersion(version) that returns true if the version is bad, false otherwise.

⚡ Constraint: Minimize the number of API calls - each call is expensive!

Example: If you have versions [1,2,3,4,5] and version 4 was the first bad one, then versions 4 and 5 are bad, while 1,2,3 are good. Your function should return 4.

Input & Output

example_1.py — Basic case

$ Input: n = 5, bad = 4 Versions: [1,2,3,4,5] isBadVersion(1) = false isBadVersion(2) = false isBadVersion(3) = false isBadVersion(4) = true isBadVersion(5) = true

› Output: 4

💡 Note: Version 4 is the first bad version. Versions 1, 2, and 3 are good, while versions 4 and 5 are bad.

example_2.py — Edge case - first version bad

$ Input: n = 1, bad = 1 Versions: [1] isBadVersion(1) = true

› Output: 1

💡 Note: The only version available is bad, so version 1 is the first (and only) bad version.

example_3.py — Large range

$ Input: n = 10, bad = 7 Versions: [1,2,3,4,5,6,7,8,9,10] Good: [1,2,3,4,5,6] Bad: [7,8,9,10]

› Output: 7

💡 Note: Version 7 is the first bad version. Using binary search, we can find this efficiently in about 3-4 API calls instead of 7.

Visualization

Tap to expand

Understanding the Visualization

The Timeline Setup

We have versions 1 through n, where good versions are followed by bad versions: GOOD|GOOD|GOOD|BAD|BAD|BAD

Binary Search Strategy

Instead of checking every version, we check the middle and eliminate half the timeline each time

Narrow Down

If middle version is good, bug is in second half. If bad, bug is in first half (including middle)

Found the Culprit

Continue until our search window contains just one version - the first bad one!

Key Takeaway

🎯 Key Insight: The boundary between good and bad versions creates a perfect binary search scenario, reducing time complexity from O(n) to O(log n) and minimizing expensive API calls!

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Each iteration eliminates half of the remaining search space, so we need at most log₂(n) iterations

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for the left, right, and mid pointers

✓ Linear Space

Constraints

1 ≤ bad ≤ n ≤ 2³¹ - 1
At least one version is guaranteed to be bad
Each call to isBadVersion() should be minimized for optimal performance

Asked in

f Facebook 45 G Google 38 ⊞ Microsoft 32 Apple 28

The optimal solution uses binary search to find the first bad version in O(log n) time. Since bad versions form a continuous range at the end, we can efficiently narrow down the search space by checking the middle version and eliminating half the possibilities each time. This reduces API calls from potentially O(n) to just O(log n).

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search (Optimal)	O(log n)	O(1)	Use binary search to efficiently find the boundary between good and bad versions
Linear Search (Brute Force)	O(n)	O(1)	Check each version sequentially from 1 to n until finding the first bad one

Binary Search (Optimal) — Algorithm Steps

Initialize left = 1, right = n
While left < right, calculate mid = left + (right - left) // 2
If isBadVersion(mid) is true, the first bad version is at mid or earlier: right = mid
If isBadVersion(mid) is false, the first bad version is after mid: left = mid + 1
Continue until left == right, which points to the first bad version

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize search range

Set left=1, right=n to cover all versions

Check middle version

Calculate mid and check if it's bad

Narrow search space

Move left or right boundary based on result

Repeat until found

Continue until left==right at the first bad version

Code -

solution.c — C

// The API isBadVersion is defined for you.
// bool isBadVersion(int version);

int firstBadVersion(int n) {
    int left = 1, right = n;
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        
        if (isBadVersion(mid)) {
            // First bad version is at mid or earlier
            right = mid;
        } else {
            // First bad version is after mid
            left = mid + 1;
        }
    }
    
    return left;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Each iteration eliminates half of the remaining search space, so we need at most log₂(n) iterations

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for the left, right, and mid pointers

✓ Linear Space

Constraints

1 ≤ bad ≤ n ≤ 2³¹ - 1
At least one version is guaranteed to be bad
Each call to isBadVersion() should be minimized for optimal performance

68.0K Views

High Frequency

~15 min Avg. Time

2.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler