First Bad Version

First Bad Version - Problem

You are a product manager and currently leading a team to develop a new product. Unfortunately, the latest version of your product fails the quality check.

Since each version is developed based on the previous version, all the versions after a bad version are also bad.

Suppose you have n versions [1, 2, ..., n] and you want to find out the first bad one, which causes all the following ones to be bad.

You are given an API bool isBadVersion(version) which returns whether version is bad. Implement a function to find the first bad version. You should minimize the number of calls to the API.

Input & Output

Example 1 — Basic Case

$ Input: n = 5, bad = 4

› Output: 4

💡 Note: Versions 1, 2, 3 are good. Version 4 is the first bad version, so versions 4 and 5 are bad. Using binary search: check version 3 (good), then check version 4 (bad), so return 4.

Example 2 — First Version Bad

$ Input: n = 1, bad = 1

› Output: 1

💡 Note: Only one version exists and it's bad, so return 1.

Example 3 — Last Version Bad

$ Input: n = 3, bad = 3

› Output: 3

💡 Note: Versions 1 and 2 are good, version 3 is the first (and only) bad version.

Constraints

1 ≤ bad ≤ n ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

f Facebook 45 G Google 38 M Microsoft 32 a Amazon 28

The key insight is recognizing this as a binary search problem on a sorted pattern: good versions followed by bad versions. The optimal approach uses binary search to minimize API calls. Time: O(log n), Space: O(1)

Common Approaches

✓ Binary Search

⏱️ Time: O(log n) Space: O(1)

Since all versions after the first bad version are also bad, we have a sorted pattern. Use binary search to eliminate half the search space in each iteration by checking the middle version.

Linear Search

⏱️ Time: O(n) Space: O(1)

Start from version 1 and check each version sequentially using the isBadVersion API. Return the first version that returns true. This is straightforward but inefficient for large n.

Binary Search — Algorithm Steps

Set left = 1, right = n
While left < right, check middle version
If middle is bad, search left half; if good, search right half
Return left when left == right

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Range

Search space is [1, n]

Check Middle

Test middle version and eliminate half

Narrow Down

Continue until finding first bad version

Code -

solution.c — C

#include <stdio.h>

int firstBad;

int isBadVersion(int version) {
    return version >= firstBad;
}

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

int main() {
    int n;
    scanf("%d", &n);
    firstBad = n > 1 ? n / 2 : 1;
    printf("%d\n", solution(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Binary search eliminates half the search space in each iteration

✓ Linear Growth

Space Complexity

O(1)

Only uses constant extra space for left, right, and mid pointers

✓ Linear Space

156.0K Views

High Frequency

~15 min Avg. Time

4.3K 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

Constraints

Visualization

Related Problems

Common Approaches

Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler