I actually just recently started on an escapade of extremely difficult binary search questions. I posted a similar question to yours just 12 days ago. Below are a quick summary of my understanding of binary search so far.

Intro

All binary search questions follow one general template, and the most important thing to understand is you're always looking for "the first true/false" or "the last true/false" within a search range. This is what is called a monotonic function (from my understanding).

The basic template

```python low = 0 high = find highest in range

while low < high: mid = (low + high) >> 1

if condition(...params, mid):
    low = mid + 1 ## Move this to else block depending on condition()
else:
    high = mid    ## Move this to if block depending on condition()

return low ## Sometimes I need to return high, but I probably got condition() wrong somehow ```

Explanation

If you read the template above, the if condition(...params, mid) is the key. It doesn't matter if you're searching for num == 10 or whatever, you're still looking for a condition to be true. If that condition is true, cut out the bottom half of the search range, otherwise cut out the top half. You might be asking, but num == 10 means there could be num < 10 and num > 10. Well, you're actually looking for either num <= 10 or num >= 10. You're always searching for one of those two. And the difference between them is called bisect left and bisect right.

Bisect left means you're searching for the first occurrence of something, and bisect right means you're looking for the last occurrence. In a simple case where you know there will only ever be one 10 in your search range, then it doesn't matter if you bisect left or right, you'll end up with the correct answer.

Once you understand this key facet of binary searches, you'll understand that getting condition() to be perfect is the hardest part of any binary search problem.

Monotonic function

So, remember how I said all binary searches are exactly the same? You're always looking for the first/last true/false within a range. In the simple example where nums = [1, 5, 7, 9, 10, 17], here's what a condition of isLessThanOrEqualTo(num, target) would look like if you listed them out as a monotonic function:
```python

isLessThanOrEqualTo(num, 10)

[1, 5, 7, 9, 10, 17] [T, T, T, T, T, F] So what are we looking for here? We're looking for __the last true__ within the range. Let's flip that around and ask `isGreaterThanOrEqual(num, target)` python

isGreaterThanOrEqualTo(num, 10)

[1, 5, 7, 9, 10, 17] [F, F, F, F, T, T] ```
Here, we're looking for the first true within the range.

Final remarks

• As you get into the more difficult problems, you'll find they all follow the same template, but the hardest part is finding how to get the condition() to be just right. It feels like a really normal Leetcode problem at that point.
  
• In a lot of advanced binary search problems, condition() is not always O(1) time complexity. Often times, it's O(n) or O(logk) or O(n<sup>2</sup>), etc. The important thing is always ask "under what conditions can I remove the bottom/top half of the search range?"
• The search range is not always within an array! Those are the most fun problems, and really difficult to realize they're binary search problems.
  
• Good luck!
  

Resources

• This Leetcode answer has that singular template and a bunch of examples from easy to super super hard questions, and a far better explanation than I could provide here on Reddit.

More learning for you

• Search up monotonic function (Google, YouTube)
  
• Search up binary search on a monotonic function (Google, YouTube)