278- First Bad Version

//Problem solution in Python.
class Solution:
    def firstBadVersion(self, n):
        """
        :type n: int
        :rtype: int
        """
        first = 0
        last = n
        while first <= last:
            mid = (first+last)//2
            if isBadVersion(mid):
                if not isBadVersion(mid-1):
                    return mid
                else:
                    last = mid - 1
            else:
                first = mid + 1
        
        return -1

//Problem solution in Java.
public class Solution extends VersionControl {
    public int firstBadVersion(int n) {
        if(n==1)
            return 1;
        int low = 1;
        int high = n;
        while(low<=high){
            int mid = low + (high-low)/2;
            if(isBadVersion(mid)){
                // move towards good version
                high = mid-1;
            }else{
                // if good version
                // move towards more recent good version
                low = mid+1;
            }
        }
        return low;
    }
}



//Problem solution in C++.
class Solution {
public:
    
    int find(int start, int end) {
        if(start>end) {
            return -1;
        }
        
        int mid = start+(end-start)/2;
        bool isBad = isBadVersion(mid);
        if(isBad && (mid == 0 ||  !isBadVersion(mid-1))) {
            return mid;
        }
        
        if(isBad) {
           return find(start, mid-1);
        } else {
            return find(mid+1, end);
        }
        
    }
    
    int firstBadVersion(int n) {
        
        return find(1, n);
        
    }
};



//Problem solution in C.
int firstBadVersion(int n) {
    int left = 1;
    int right = n;
    
    while(left<right){
       int mid = left + (right-left)/2;
        
        if(isBadVersion(mid)){
            right = mid;
        }
        else{
            left = mid + 1; 
        }
    }
    return left;
}