Binary Search

Implement a half-open first-true template in C++ using a callable predicate.

Implement a last-true template in C++ using explicit sentinel bounds.

Map `std::lower_bound` to the first position satisfying `value >= target`.

Map `std::upper_bound` to the first position satisfying `value > target`.

Use `std::equal_range` to obtain the full range of duplicate values.

Apply a custom comparator without violating the ordering required by STL binary-search algorithms.

Construct an edge-case test suite covering empty, singleton, duplicate, and all-false or all-true inputs.

Differential-test a binary-search implementation against a linear reference implementation.

Find the first and last occurrence of a target in a sorted vector with duplicates.

Compute the insertion interval of a value in a sorted vector.

Find the minimum element in a rotated sorted vector with distinct values.

Find a target in a rotated sorted vector with distinct values.

Adapt rotated-array search to duplicates and identify when worst-case linear behavior occurs.

Find a peak index in a mountain array by searching the slope transition.

Search a row-major sorted matrix by treating it as a virtual one-dimensional array.

Find the k-th missing positive integer using a monotone missing-count function.

Use exponential expansion to bracket a target when no finite upper bound is initially known.

Combine exponential bracketing with boundary search to find the first true value on an unbounded integer domain.

Search a sorted sequence exposed through a bounds-checked accessor without knowing its length.

Derive the comparison complexity of exponential search in terms of the target position.

Choose safe stopping conditions when exponential expansion approaches an integer limit.

Convert a discrete minimization problem into a monotone feasibility decision problem.

Convert a discrete maximization problem into a monotone feasibility decision problem.

Prove the monotonicity of a feasibility predicate before searching its answer domain.

Derive valid lower and upper answer bounds from problem constraints.

Choose sentinel states for minimum-feasible and maximum-feasible searches.

Implement a minimum-feasible answer search with 64-bit-safe arithmetic.

Implement a maximum-feasible answer search with 64-bit-safe arithmetic.

Derive the total complexity as the product of search iterations and predicate cost.

Find the minimum ship capacity needed to meet a delivery deadline using a greedy feasibility scan.

Minimize the largest contiguous partition sum when splitting an array into at most k parts.

Find the minimum processing speed needed to finish workloads by a deadline.

Maximize the minimum distance between selected positions using greedy placement.

Find the earliest day on which a required number of adjacent groups can be formed.

Find the minimum time for parallel machines to produce a target number of items.

Prove that a left-to-right greedy scan correctly decides a capacity-constrained partition problem.

Brute-force small instances to validate a greedy feasibility predicate before binary searching.

Find the k-th smallest value in a row-wise sorted matrix using a count-at-most predicate.

Find the k-th smallest value in a multiplication table using quotient-based counting.

Find the k-th smallest pair distance using sorting and a two-pointer count predicate.

Compute the number of pair sums not exceeding a candidate threshold.

Binary-search the k-th smallest pair sum using the pair-count predicate.

Prevent overflow in cumulative counts by saturating once the count reaches k.

Compare value-domain binary search with index-domain binary search for an order-statistic problem.

Verify that a real-valued decision predicate changes truth value monotonically over a chosen interval.

Choose an absolute-error stopping rule for continuous binary search.

Calculate a fixed iteration count needed for a target precision.

Approximate a nonnegative square root by continuous binary search.

Approximate an n-th root while handling inputs between zero and one.

Solve a monotone geometric threshold problem using continuous binary search.

Avoid unstable equality comparisons at a floating-point boundary.

Bound the final approximation error from the width of the remaining interval.

Represent a combined left partition of two sorted arrays using one cut index.

Derive the feasible range of the cut in the shorter array.

Determine the search direction when a candidate partition violates cross-boundary ordering.

Find the k-th element of two sorted arrays using partition-based binary search.

Compute the median of two sorted arrays for an odd combined length.

Compute the median of two sorted arrays for an even combined length without arithmetic overflow.

Handle empty and highly imbalanced arrays in partition-based search.

Classify an unseen problem as exact-match, boundary, answer-domain, continuous, or partition-based binary search.

Select a search interval and predicate for an unseen monotone problem.

Generate a minimal counterexample for an off-by-one error in a binary-search loop.

Diagnose a nonterminating binary search from its invariant and update rules.

Explain a binary-search solution using its contract, invariant, termination argument, and complexity.

Decide when an STL boundary algorithm is preferable to a manual C++ implementation.

Solve an unseen integer answer-search problem within a 45-minute interview-style time limit.

Solve an unseen counting-predicate problem within a 45-minute competitive-programming time limit.