**Physical Address**

304 North Cardinal St.

Dorchester Center, MA 02124

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.

**Example 1:**

```
Input: n = 5, bad = 4
Output: 4
Explanation:
call isBadVersion(3) -> false
call isBadVersion(5) -> true
call isBadVersion(4) -> true
Then 4 is the first bad version.
```

**Example 2:**

```
Input: n = 1, bad = 1
Output: 1
```

**Constraints:**

`1 <= bad <= n <= 2`

^{31}- 1

```
class Solution:
def firstBadVersion(self, n) -> int:
left, right = 1, n
while left < right:
mid = left + (right - left) // 2
if isBadVersion(mid):
right = mid
else:
left = mid + 1
return left
```

```
public class Solution extends VersionControl {
public int firstBadVersion(int n) {
int left = 1, right = n, ans = -1;
while (left <= right) {
int mid = left + (right - left) / 2; // to avoid overflow incase (left+right)>2147483647
if (isBadVersion(mid)) {
ans = mid; // record mid as current answer
right = mid - 1; // try to find smaller version in the left side
} else {
left = mid + 1; // try to find in the right side
}
}
return ans;
}
}
```

```
class Solution {
public:
int firstBadVersion(int n) {
int lower = 1, upper = n, mid;
while(lower < upper) {
mid = lower + (upper - lower) / 2;
if(!isBadVersion(mid)) lower = mid + 1; /* Only one call to API */
else upper = mid;
}
return lower; /* Because there will alway be a bad version, return lower here */
}
};
```

In our experience, we suggest you solve this First Bad Version LeetCode Solution and gain some new skills from Professionals completely free and we assure you will be worth it.

If you are stuck anywhere between any coding problem, just visit Queslers to get the First Bad Version LeetCode Solution

I hope this First Bad Version LeetCode Solution would be useful for you to learn something new from this problem. If it helped you then don’t forget to bookmark our site for more Coding Solutions.

This Problem is intended for audiences of all experiences who are interested in learning about Data Science in a business context; there are no prerequisites.

Keep Learning!

**More Coding Solutions >>**