Finding the Boundary with Binary Search

Prereq: Binary Search Introduction

An array of boolean values is divided into two sections; the left section consists of all false and the right section consists of all true. Find the boundary of the right section, i.e. the index of the first true element. If there is no true element, return -1.

Input: arr = [false, false, true, true, true]

Output: 2

Explanation: first true's index is 2.

Try it yourself

Explanation

The binary decision we have to make when we look at an element is

  1. if the element is false, we discard everything to the left and the current element itself.
  2. if the element is true, the current element could be the first true although there may be other true to the left. We discard everything to the right but what about the current element?

We can either keep the current element in the range or record it somewhere and then discard it. Here we choose the latter. We'll discuss the other approach in the alternative solution section.

We keep a variable boundary_index that represents the leftmost true's index currently recorded. If the current element is true, then we update boundary_index with its index and discard everything to the right including the current element itself since its index has been recorded by the variable.

Time Complexity: O(log(n))

First slide
First slide
First slide
First slide
First slide
First slide
First slide
First slide
First slide

Implementation

1from typing import List
2
3def find_boundary(arr: List[bool]) -> int:
4    left, right = 0, len(arr) - 1
5    boundary_index = -1
6
7    while left <= right:
8        mid = (left + right) // 2
9        if arr[mid]:
10            boundary_index = mid
11            right = mid - 1
12        else:
13            left = mid + 1
14
15    return boundary_index
16
17if __name__ == '__main__':
18    arr = [x == "true" for x in input().split()]
19    res = find_boundary(arr)
20    print(res)
21
1import java.io.IOException;
2import java.util.Scanner;
3
4class Solution {
5
6    public static int findBoundary(boolean[] arr) {
7        int left = 0;
8        int right = arr.length - 1;
9        int boundaryIndex = -1;
10        while (left <= right) {
11            int mid = left + (right - left) / 2;
12            if (arr[mid]) {
13                boundaryIndex = mid;
14                right = mid - 1;
15            } else {
16                left = mid + 1;
17            }
18        }
19        return boundaryIndex;
20    }
21
22    public static void main(String[] args) throws IOException {
23        Scanner scanner = new Scanner(System.in);
24        String[] input = scanner.nextLine().split(" ");
25        scanner.close();
26        boolean[] arr = new boolean[input.length];
27        for (int i = 0; i < input.length; i++) {
28            arr[i] = input[i].equals("true");
29        }
30        System.out.println(findBoundary(arr));
31    }
32
33}
34
1using System;
2using System.Collections.Generic;
3using System.Linq;
4
5class Solution
6{
7    public static int FindBoundary(List<bool> arr)
8    {
9        int left = 0;
10        int right = arr.Count - 1;
11        int boundaryIndex = -1;
12        while (left <= right)
13        {
14            int mid = (left + right) / 2;
15            if (arr[mid])
16            {
17                boundaryIndex = mid;
18                right = mid - 1;
19            }
20            else
21            {
22                left = mid + 1;
23            }
24        }
25        return boundaryIndex;
26    }
27
28    public static List<string> SplitWords(string s)
29    {
30    return string.IsNullOrEmpty(s) ? new List<string>() : s.Split(' ').ToList();
31    }
32
33    public static void Main()
34    {
35        List<bool> arr = SplitWords(Console.ReadLine()).Select(bool.Parse).ToList();
36        int res = FindBoundary(arr);
37        Console.WriteLine(res);
38    }
39
40}
41
1const readline = require('readline');
2
3function find_boundary(arr) {
4    let left = 0;
5    let right = arr.length - 1;
6    let boundary_index = -1;
7
8    while (left <= right) {
9        let mid = Math.floor((left + right) / 2);
10        if (arr[mid]) {
11            boundary_index = mid;
12            right = mid - 1;
13        } else {
14            left = mid + 1;
15        }
16    }
17    return boundary_index;
18}
19
20const rl = readline.createInterface(process.stdin);
21rl.on('line', (input) => {
22    const arr = input.split(" ").map(bool => (bool == "true"));
23    rl.close();
24    console.log(find_boundary(arr));
25});
26
1#include <algorithm> // copy
2#include <iostream> // cin, cout
3#include <iterator> // back_inserter, istream_iterator
4#include <sstream> // istringstream
5#include <string> // getline, string
6#include <vector> // vector
7
8int find_boundary(std::vector<bool> arr) {
9    int left = 0;
10    int right = arr.size() - 1;
11    int boundaryIndex = -1;
12    while (left <= right) {
13        int mid = left + (right - left) / 2;
14        if (arr[mid]) {
15            boundaryIndex = mid;
16            right = mid - 1;
17        } else {
18            left = mid + 1;
19        }
20    }
21    return boundaryIndex;
22}
23
24int main() {
25    std::string line;
26    std::getline(std::cin, line);
27    std::istringstream ss{line};
28    std::vector<bool> arr;
29    bool b;
30    while (ss >> std::boolalpha >> b) {
31        arr.push_back(b);
32    }
33    int res = find_boundary(arr);
34    std::cout << res << '\n';
35}
36
1package main
2
3import (
4    "bufio"
5    "fmt"
6    "os"
7    "strconv"
8    "strings"
9)
10
11func findBoundary(arr []bool) int {
12    left := 0
13    right := len(arr) - 1
14    boundaryIndex := -1
15    for left <= right {
16        mid := (left + right) / 2
17        if arr[mid] {
18            boundaryIndex = mid
19            right = mid - 1
20        } else {
21            left = mid + 1
22        }
23    }
24    return boundaryIndex
25}
26
27func arrayAtob(arr []string) []bool {
28    res := []bool{}
29    for _, x := range arr {
30        v, _ := strconv.ParseBool(x)
31        res = append(res, v)
32    }
33    return res
34}
35
36func splitWords(s string) []string {
37    if s == "" {
38        return []string{}
39    }
40    return strings.Split(s, " ")
41}
42
43func main() {
44    scanner := bufio.NewScanner(os.Stdin)
45    scanner.Scan()
46    arr := arrayAtob(splitWords(scanner.Text()))
47    res := findBoundary(arr)
48    fmt.Println(res)
49}
50
1import           Data.Array (Array, bounds, listArray, (!))
2
3findBoundary :: Array Int Bool -> Int
4findBoundary arr = uncurry (search (-1)) $ bounds arr where
5  search b l r
6    | l > r     = b
7    | arr ! m   = search m l (pred m)
8    | otherwise = search b (succ m) r
9    where m = l + (r - l) `div` 2
10
11main :: IO ()
12main = do
13  arr' <- map (== "true") . words <$> getLine
14  let arr = listArray (0, length arr' - 1) arr'
15      res = findBoundary arr
16  print res
17

The good thing with this approach is that we don't have to modify the while loop logic in the vanilla binary search from the last module, besides introducing a variable.

Alternative approach

Another approach to handle case 2 above is to keep the current element in the search range instead of discarding it, i.e. if arr[mid]: right = mid instead of right = mid - 1. However, doing this without modifying the while condition will result in an infinite loop. This is because when left == right, right = mid will not modify right and thus, not shrink search range and we will be stuck in the while loop forever. To make this work we have to remove the equality in the while condition. In addition, as mentioned in the last module, a while loop without equality will miss the single-element edge case so we have to add an additional check after the loop to handle this case. Overall, we have to make three modifications to the vanilla binary search to make it work.

Side note: how to not get stuck in an infinite loop

  • make progress in each step
  • have an exit strategy

Summary

This problem is a major 🔑 in solving future binary search-related problems. As we will see in the following modules, many problems boil down to finding the boundary in a boolean array.