int firstBadVersion(int n) {
auto l = 1, h = n;
if (n == 1) {
return isBadVersion(n) ? n : 0;
}
while (h >= l) {
auto mid = l/2 + h/2;
auto res = isBadVersion(mid);
auto ismid = res && (mid == 1 || !isBadVersion(mid-1));
if (ismid) {
return mid;
}
if (!res && isBadVersion(mid+1)) {
return mid + 1;
}
if (res) {
h = mid - 1;
} else {
l = mid + 1;
}
}
return -1;
}
int firstBadVersion(int n) {
int low = 1, high = n;
int mid;
int result = 0;
if(n == 1)
return 1;
while(low < high) {
if((low + 1 == high)) {
result = isBadVersion(low);
if(result == 1)
return low;
else
return high;
}
mid = low + (high - low)/2;
result = isBadVersion(mid);
if(result == 0) {
low = mid;
}
else {
high = mid;
}
}
return -1;
}
int bst(long n1,long n2)
{
if(!isBadVersion(n2-1)&&isBadVersion(n2))return n2;
int l=(n1+n2)/2;
if(!isBadVersion(l)&&isBadVersion(l+1))return l+1;
else if(isBadVersion(l))return bst(n1,l);
else return bst(l+1,n2);
}
//1. Not AC , Time Limit Exceeded
int firstBadVersion1(int n) {
if(!isBadVersion(n)) // last is not , there is no
return -1;
for(int i=1; i<= n; i++)
if(isBadVersion(i))
return i;
}
// 2.
int firstBadVersion(int n) {
if(!isBadVersion(n)) // last is not , there is no
return -1;
int left=1, right=n;
while(left < right){
int mid = left + (right-left)/2;
if(isBadVersion(mid))
right = mid; // need the smallest bad
else left = mid+1; // the bad is on the right
}
return isBadVersion(left) ? left : right;
}
long firstBadVersion(long n, long stepsize) {
if (stepsize == 1 && isBadVersion(n)) return (n);
if (!isBadVersion(n)) {
long jumpto = n+stepsize;
if (jumpto > number && stepsize == 1) {
return number; //error case
} else if (jumpto > number) {
return firstBadVersion(n+1, 1);
} else {
return firstBadVersion(jumpto, stepsize*2);
}
}
return firstBadVersion(n-(stepsize/2)+1, 1);
}
int firstBadVersion(int n)
{
auto mid = [](int i, int j){uint64_t k = (uint64_t)i + j; return k / 2;};
int s = 1, e = n;
while (e - s > 1)
{
if (isBadVersion(mid(s, e)))
e = mid(s, e);
else
s = mid(s, e);
cout << s << ", " << e << endl;
}
return isBadVersion(s) ? s : e;
}
//Binary search
int firstBadVersion(int n) {
int low=1, high=n;
while(low <= high) {
int mid = low + (high - low)/2;
if (isBadVersion(mid) && !isBadVersion(mid-1)){
return mid;
}
if (isBadVersion(mid)) {
high = mid - 1;
}else{
low = mid + 1;
}
}
return -1;
}
int firstBadVersion(int n){
int low = 1, high = n;
while(low >0 && high < n){
//int mid = (low + high)/2;
int mid = low + (low + high)/2;
if(isBadVersion(mid) && !isBadVersion(mid-1)
return mid;
if(isBadVersion(mid)){
high = mid-1;
}else{
low = mid+1;
}
}
return -1;
}
int firstBadVersion(int n) {
int left = 1, right = n;
while (left < right) {
int mid = left + (right - left) / 2; // avoid overflow
if (isBadVersion(mid)) {
right = mid - 1;
} else {
left = mid + 1;
}
}
if (isBadVersion(left)) {
return left;
} else {
return left + 1;
}
}
int firstBadVersion(int n)
{
int s = 1, e = n, m = 0;
while (s <= e)
{
m = s + (e - s)/2;
if ( (isBadVersion(m) && s == m) || (isBadVersion(m) && !isBadVersion(m-1)))
break;
else if (isBadVersion(m))
e = m-1;
else
s = m + 1;
}
return m;
}
int firstBadVersion(int n)
{
int mid;
int low, high;
int bad;
low = 1;
high = n;
while (low <= high)
{
mid = (high - low) / 2 + low;
if (isBadVersion(mid))
{
bad = mid;
high = mid - 1;
}
else
{
low = mid + 1;
}
}
return bad;
}
int firstBadVersion(int n) {
int a = 1;
int b = n;
int c = 0;
while (b-a>1)
{
c = a + (b-a)/2; // Overflow issue!
if (isBadVersion(c))
b = c;
else
a = c;
}
return isBadVersion(a) ? a : b;
}
//AC - 0ms;
int firstBadVersion(int n)
{
int low = 1, high = n;
int mid;
while(low < high)
isBadVersion(mid = low+(high-low)/2) ? (high = mid) : (low = mid+1);
return high;
}
int firstBadVersion(int n) {
int low = 1, high = n;
while (low <= high) {
int mid = low + (high - low)/2;
if (isBadVersion(mid)) high = mid - 1;
else low = mid + 1;
}
return low;
}
int firstBadVersion(int n) {
int left=1, right=n;
while(left<=right) {
int mid=left+(right-left)/2;
if(isBadVersion(mid)) right=mid-1;
else left=mid+1;
}
return left;
}
int firstBadVersion(int n) {
int p = 1, q = n;
while(p < q) {
int c = p + (q-p)/2;
if(isBadVersion(c)) {
q = c;
}
else {
p = c+1;
}
}
return isBadVersion(p)? p:p+1;
}
int firstBadVersion(int n) {
long left = 1;
long right = n;
while(left < right){
long mid = (left + right)/2; // overflow
if(isBadVersion(mid)) right = mid;
else left = mid + 1;
}
return left;
}
int firstBadVersion(int n) {
int l = 1,r = n, mid = (l+r)/2;
for (; l<r;mid = l/2+r/2+(l&1&r)) {
if (isBadVersion(mid)) {
r = mid;
}
else
l = mid+1;
}
return mid;
}
int firstBadVersion(int n) {
int s=0,t,first=n;
while(s<=n){
t=(s+n)/2;
if(isBadVersion(t)){
first=first<t?first:t;
n=t-1;
}else s=t+1;
}
return first;
}
int firstBadVersion(int n)
{
int b = 1, e = n;
while (b < e)
{
int m = b + (e - b) / 2;
if (!isBadVersion(m)) b = m + 1;
else e = m;
}
return b;
}
int firstBadVersion(int n) {
int b = 1, e = n;
while (b <= e) {
int m = b + (e - b) / 2;
if (isBadVersion(m))
e = m - 1;
else
b = m + 1;
}
return b;
}
int firstBadVersion(int n) {
int low = 1 , high = n , ans = -1;
while (low <= high) {
int mid = low + ((high - low) >> 1);
if (isBadVersion (mid)) {
ans = mid;
high = mid - 1;
}
else low = mid + 1;
}
return ans;
}
//利用二分查找
int firstBadVersion(int n) {
long long begin = 1, end = n, mid = 1;
while (begin <= end){
mid = (begin + end) / 2;
if (!isBadVersion(mid)){
begin = mid + 1;
}
else
end = mid - 1;
}
return begin;
}
/*TLE
int firstBadVersion(int n) {
for (int i = 1; i <= n; i++) {
if (isBadVersion(i))
return i;
}
}*/
int firstBadVersion(int n) {
int start = 1, end = n;
while (start < end) {
int mid = start + ((end - start) >> 1);
if (isBadVersion(mid))
end = mid;
else
start = mid + 1;
}
return start;
}
int firstBadVersion_update(int n)
{
int lhs = 1, rhs = n;
while(lhs < rhs)
{
int mid = lhs + (rhs - lhs)/2;
bool bad = isBadVersion(mid);
if(bad) rhs = mid;
else lhs = mid+1;
}
return lhs;
}
int firstBadVersion(int n) {
int start = 0, end = n;
n = start / 2 + end / 2;
while (start != end) {
if (isBadVersion(n))
end = n;
else
start = n + 1;
n = start / 2 + end / 2;
}
return start;
}
int firstBadVersion(int n) {
ll i = 1;
ll j = n;
while(i != j){
ll mid = (i+j)/2;
bool now = isBadVersion(mid);
if(now == true)
j = mid;
else
i = mid+1;
}
return (int)i;
}
// binary search 0 0 0 0 0 1 1 1 1 1 1 will find the first 1
// time complexity is O(logn) and space complexity is O(1)
int firstBadVersion(int n)
{
int lhs = 1, rhs = n;
// we want to have at least two neighboring versions left
while (lhs + 1 < rhs)
{
int mid = lhs + (rhs - lhs) / 2;
bool bad = isBadVersion(mid);
if (bad)
{
rhs = mid;
}
else
{
lhs = mid;
}
}
if (isBadVersion(lhs)) return lhs;
else if (isBadVersion(rhs)) return rhs;
return 0;
}
int firstBadVersion(int n) {
long l = 1;
long r = n;
long mid;
while (l < r) {
mid = (l + r) / 2;
if (isBadVersion(mid))
r = mid;
else
l = mid + 1;
}
return r;
}
