Codestin Search App

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.

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

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!

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
✓ 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)	O(log n)	O(1)	Use binary search to efficiently find the boundary between good and bad versions

Linear Search (Brute Force) — Algorithm Steps

Start from version 1
Call isBadVersion() for each version sequentially
Return the first version that returns true
Continue until we find the first bad version

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from version 1

Begin checking from the first version

Check each version sequentially

Call isBadVersion() for each version in order

Stop at first bad version

Return immediately when we find the first bad version

Code -

solution.c — C

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

int firstBadVersion(int n) {
    for (int version = 1; version <= n; version++) {
        if (isBadVersion(version)) {
            return version;
        }
    }
    return n; // This should never be reached
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case, we might need to check all n versions if the first bad version is at the end

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for the loop variable

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Linear Search (Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler