Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Unbounded Binary Search Example (Find the point where a monotonically increasing function becomes positive first time)

  • Difficulty Level : Easy
  • Last Updated : 10 May, 2021

Given a function ‘int f(unsigned int x)’ which takes a non-negative integer ‘x’ as input and returns an integer as output. The function is monotonically increasing with respect to the value of x, i.e., the value of f(x+1) is greater than f(x) for every input x. Find the value ‘n’ where f() becomes positive for the first time. Since f() is monotonically increasing, values of f(n+1), f(n+2),… must be positive and values of f(n-2), f(n-3), … must be negative. 
Find n in O(logn) time, you may assume that f(x) can be evaluated in O(1) time for any input x. 

A simple solution is to start from i equals to 0 and one by one calculate the value of f(i) for 1, 2, 3, 4 … etc until we find a positive f(i). This works but takes O(n) time.
Can we apply Binary Search to find n in O(Logn) time? We can’t directly apply Binary Search as we don’t have an upper limit or high index. The idea is to do repeated doubling until we find a positive value, i.e., check values of f() for following values until f(i) becomes positive.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

  f(0) 
  f(1)
  f(2)
  f(4)
  f(8)
  f(16)
  f(32)
  ....
  ....
  f(high)
Let 'high' be the value of i when f() becomes positive for first time.

Can we apply Binary Search to find n after finding ‘high’? We can apply Binary Search now, we can use ‘high/2’ as low and ‘high’ as high indexes in binary search. The result n must lie between ‘high/2’ and ‘high’.
The number of steps for finding ‘high’ is O(Logn). So we can find ‘high’ in O(Logn) time. What about the time taken by Binary Search between high/2 and high? The value of ‘high’ must be less than 2*n. The number of elements between high/2 and high must be O(n). Therefore, the time complexity of Binary Search is O(Logn) and the overall time complexity is 2*O(Logn) which is O(Logn). 
 

C++




// C++ code for binary search
#include<bits/stdc++.h>
using namespace std;
 
int binarySearch(int low, int high); // prototype
 
// Let's take an example function
// as f(x) = x^2 - 10*x - 20 Note that
// f(x) can be any monotonocally increasing function
int f(int x) { return (x*x - 10*x - 20); }
 
// Returns the value x where above
// function f() becomes positive
// first time.
int findFirstPositive()
{
    // When first value itself is positive
    if (f(0) > 0)
        return 0;
 
    // Find 'high' for binary search by repeated doubling
    int i = 1;
    while (f(i) <= 0)
        i = i*2;
 
    // Call binary search
    return binarySearch(i/2, i);
}
 
// Searches first positive value
// of f(i) where low <= i <= high
int binarySearch(int low, int high)
{
    if (high >= low)
    {
        int mid = low + (high - low)/2; /* mid = (low + high)/2 */
 
        // If f(mid) is greater than 0 and
        // one of the following two
        // conditions is true:
        // a) mid is equal to low
        // b) f(mid-1) is negative
        if (f(mid) > 0 && (mid == low || f(mid-1) <= 0))
            return mid;
 
        // If f(mid) is smaller than or equal to 0
        if (f(mid) <= 0)
            return binarySearch((mid + 1), high);
        else // f(mid) > 0
            return binarySearch(low, (mid -1));
    }
 
    /* Return -1 if there is no
    positive value in given range */
    return -1;
}
 
/* Driver code */
int main()
{
    cout<<"The value n where f() becomes" <<
        "positive first is "<< findFirstPositive();
    return 0;
}
 
// This code is contributed by rathbhupendra
C



#include <stdio.h>
int binarySearch(int low, int high); // prototype
 
// Let's take an example function as f(x) = x^2 - 10*x - 20
// Note that f(x) can be any monotonocally increasing function
int f(int x) { return (x*x - 10*x - 20); }
 
// Returns the value x where above function f() becomes positive
// first time.
int findFirstPositive()
{
    // When first value itself is positive
    if (f(0) > 0)
        return 0;
 
    // Find 'high' for binary search by repeated doubling
    int i = 1;
    while (f(i) <= 0)
        i = i*2;
 
    //  Call binary search
    return binarySearch(i/2, i);
}
 
// Searches first positive value of f(i) where low <= i <= high
int binarySearch(int low, int high)
{
    if (high >= low)
    {
        int mid = low + (high - low)/2; /* mid = (low + high)/2 */
 
        // If f(mid) is greater than 0 and one of the following two
        // conditions is true:
        // a) mid is equal to low
        // b) f(mid-1) is negative
        if (f(mid) > 0 && (mid == low || f(mid-1) <= 0))
            return mid;
 
        // If f(mid) is smaller than or equal to 0
        if (f(mid) <= 0)
            return binarySearch((mid + 1), high);
        else // f(mid) > 0
            return binarySearch(low, (mid -1));
    }
 
    /* Return -1 if there is no positive value in given range */
    return -1;
}
 
/* Driver program to check above functions */
int main()
{
    printf("The value n where f() becomes positive first is %d",
           findFirstPositive());
    return 0;
}
Java



// Java program for Binary Search
import java.util.*;
 
class Binary
{
    public static int f(int x)
    { return (x*x - 10*x - 20); }
 
    // Returns the value x where above
    // function f() becomes positive
    // first time.
    public static int findFirstPositive()
    {
        // When first value itself is positive
        if (f(0) > 0)
            return 0;
 
        // Find 'high' for binary search
        // by repeated doubling
        int i = 1;
        while (f(i) <= 0)
            i = i * 2;
 
        // Call binary search
        return binarySearch(i / 2, i);
    }
 
    // Searches first positive value of
    // f(i) where low <= i <= high
    public static int binarySearch(int low, int high)
    {
        if (high >= low)
        {  
            /* mid = (low + high)/2 */
            int mid = low + (high - low)/2;
 
            // If f(mid) is greater than 0 and
            // one of the following two
            // conditions is true:
            // a) mid is equal to low
            // b) f(mid-1) is negative
            if (f(mid) > 0 && (mid == low || f(mid-1) <= 0))
                return mid;
 
            // If f(mid) is smaller than or equal to 0
            if (f(mid) <= 0)
                return binarySearch((mid + 1), high);
            else // f(mid) > 0
                return binarySearch(low, (mid -1));
        }
 
        /* Return -1 if there is no positive
        value in given range */
        return -1;
    }
     
    // driver code
    public static void main(String[] args)
    {
        System.out.print ("The value n where f() "+
                         "becomes positive first is "+
                         findFirstPositive());
    }
}
 
// This code is contributed by rishabh_jain
Python3



# Python3 program for Unbound Binary search.
 
# Let's take an example function as
# f(x) = x^2 - 10*x - 20
# Note that f(x) can be any monotonocally
# increasing function
def f(x):
    return (x * x - 10 * x - 20)
 
# Returns the value x where above function
# f() becomes positive first time.
def findFirstPositive() :
     
    # When first value itself is positive
    if (f(0) > 0):
        return 0
 
    # Find 'high' for binary search
    # by repeated doubling
    i = 1
    while (f(i) <= 0) :
        i = i * 2
 
    # Call binary search
    return binarySearch(i/2, i)
 
# Searches first positive value of
# f(i) where low <= i <= high
def binarySearch(low, high):
    if (high >= low) :
         
        # mid = (low + high)/2
        mid = low + (high - low)/2; 
 
        # If f(mid) is greater than 0
        # and one of the following two
        # conditions is true:
        # a) mid is equal to low
        # b) f(mid-1) is negative
        if (f(mid) > 0 and (mid == low or f(mid-1) <= 0)) :
            return mid;
 
        # If f(mid) is smaller than or equal to 0
        if (f(mid) <= 0) :
            return binarySearch((mid + 1), high)
        else : # f(mid) > 0
            return binarySearch(low, (mid -1))
     
    # Return -1 if there is no positive
    # value in given range
    return -1;
 
# Driver Code
print ("The value n where f() becomes "+
      "positive first is ", findFirstPositive());
 
# This code is contributed by rishabh_jain
C#



// C# program for Binary Search
using System;
 
class Binary
{
    public static int f(int x)
    {
        return (x*x - 10*x - 20);
    }
 
    // Returns the value x where above
    // function f() becomes positive
    // first time.
    public static int findFirstPositive()
    {
        // When first value itself is positive
        if (f(0) > 0)
            return 0;
 
        // Find 'high' for binary search
        // by repeated doubling
        int i = 1;
        while (f(i) <= 0)
            i = i * 2;
 
        // Call binary search
        return binarySearch(i / 2, i);
    }
 
    // Searches first positive value of
    // f(i) where low <= i <= high
    public static int binarySearch(int low, int high)
    {
        if (high >= low)
        {
            /* mid = (low + high)/2 */
            int mid = low + (high - low)/2;
 
            // If f(mid) is greater than 0 and
            // one of the following two
            // conditions is true:
            // a) mid is equal to low
            // b) f(mid-1) is negative
            if (f(mid) > 0 && (mid == low ||
                             f(mid-1) <= 0))
                return mid;
 
            // If f(mid) is smaller than or equal to 0
            if (f(mid) <= 0)
                return binarySearch((mid + 1), high);
            else
             
                // f(mid) > 0
                return binarySearch(low, (mid -1));
        }
 
        /* Return -1 if there is no positive
        value in given range */
        return -1;
    }
     
    // Driver code
    public static void Main()
    {
       Console.Write ("The value n where f() " +
                      "becomes positive first is " +
                       findFirstPositive());
    }
}
 
// This code is contributed by nitin mittal
PHP



<?php
// PHP program for Binary Search
 
// Let's take an example function
// as f(x) = x^2 - 10*x - 20
// Note that f(x) can be any
// monotonocally increasing function
function f($x)
{
    return ($x * $x - 10 * $x - 20);
}
 
// Returns the value x where above
// function f() becomes positive
// first time.
function findFirstPositive()
{
    // When first value
    // itself is positive
    if (f(0) > 0)
        return 0;
 
    // Find 'high' for binary
    // search by repeated doubling
    $i = 1;
    while (f($i) <= 0)
        $i = $i * 2;
 
    // Call binary search
    return binarySearch(intval($i / 2), $i);
}
 
// Searches first positive value
// of f(i) where low <= i <= high
function binarySearch($low, $high)
{
    if ($high >= $low)
    {
        /* mid = (low + high)/2 */
        $mid = $low + intval(($high -
                              $low) / 2);
 
        // If f(mid) is greater than 0
        // and one of the following two
        // conditions is true:
        // a) mid is equal to low
        // b) f(mid-1) is negative
        if (f($mid) > 0 && ($mid == $low ||
                          f($mid - 1) <= 0))
            return $mid;
 
        // If f(mid) is smaller
        // than or equal to 0
        if (f($mid) <= 0)
            return binarySearch(($mid + 1), $high);
        else // f(mid) > 0
            return binarySearch($low, ($mid - 1));
    }
 
    /* Return -1 if there is no
    positive value in given range */
    return -1;
}
 
// Driver Code
echo "The value n where f() becomes ".
                 "positive first is ".
                 findFirstPositive() ;
 
// This code is contributed by Sam007
?>
Javascript



<script>
    // Javascript program for Binary Search
     
    function f(x)
    {
        return (x*x - 10*x - 20);
    }
   
    // Returns the value x where above
    // function f() becomes positive
    // first time.
    function findFirstPositive()
    {
        // When first value itself is positive
        if (f(0) > 0)
            return 0;
   
        // Find 'high' for binary search
        // by repeated doubling
        let i = 1;
        while (f(i) <= 0)
            i = i * 2;
   
        // Call binary search
        return binarySearch(parseInt(i / 2, 10), i);
    }
   
    // Searches first positive value of
    // f(i) where low <= i <= high
    function binarySearch(low, high)
    {
        if (high >= low)
        {
            /* mid = (low + high)/2 */
            let mid = low + parseInt((high - low)/2, 10);
   
            // If f(mid) is greater than 0 and
            // one of the following two
            // conditions is true:
            // a) mid is equal to low
            // b) f(mid-1) is negative
            if (f(mid) > 0 && (mid == low ||
                             f(mid-1) <= 0))
                return mid;
   
            // If f(mid) is smaller than or equal to 0
            if (f(mid) <= 0)
                return binarySearch((mid + 1), high);
            else
               
                // f(mid) > 0
                return binarySearch(low, (mid -1));
        }
   
        /* Return -1 if there is no positive
        value in given range */
        return -1;
    }
     
    document.write ("The value n where f() " +
                      "becomes positive first is " +
                       findFirstPositive());
 
</script>
Output : 
The value n where f() becomes positive first is 12
 



My Personal Notes
arrow_drop_up
Previous
Recursive function to do substring search
Next

Program to check if a given number is Lucky (all digits are different)
Recommended Articles
Page :
Meta Binary Search | One-Sided Binary Search
24, Oct 18
Binary Search for Rational Numbers without using floating point arithmetic
25, Nov 15
Best First Search (Informed Search)
03, May 17
Find minimum value to assign all array elements so that array product becomes greater
21, Jun 17
Interpolation search vs Binary search
12, May 11
Linear Search vs Binary Search
20, Oct 16
Why is Binary Search preferred over Ternary Search?
14, Dec 14
Remove minimum elements from the array such that 2*min becomes more than max
18, Jul 19
Minimize value of a in series a, a/b^1, a/b^2, a/b^3, ..., a/b^n such that sum of initial non-zero terms becomes at least S
16, Nov 21
Find the maximum element in an array which is first increasing and then decreasing
14, Jan 12
Count of permutations of first N positive integers such that sum of any two consecutive numbers is prime
16, Nov 21
Find the transition point in a binary array
17, Jun 17
Sublist Search (Search a linked list in another list)
18, Jan 17
Repeatedly search an element by doubling it after every successful search
24, Aug 17
Minimum in an array which is first decreasing then increasing
22, Dec 18
Find square root of number upto given precision using binary search
03, Mar 18
Find H-Index for sorted citations using Binary Search
17, Sep 20
Rearrange Array to find K using Binary Search algorithm without sorting
27, Jul 21
Best meeting point in 2D binary array
06, Sep 17
Left rotate digits of node values of all levels of a Binary Tree in increasing order
23, Mar 21
Check if a Binary Tree contains node values in strictly increasing and decreasing order at even and odd levels
09, Oct 20
Find the smallest positive number missing from an unsorted array | Set 2
24, Jun 18
Find minimum positive integer x such that a(x^2) + b(x) + c >= k
15, Apr 19
Find the maximum among the count of positive or negative integers in the array
07, Oct 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!