Binary Search can be categorized into which of the following?

Concept: Divide and Conquer is an algorithmic paradigm that solves a problem by (1) dividing it into smaller subproblems of the same type, (2) conquering each subproblem — usually by recursion — and (3) combining the results. In its classic form (e.g. Merge Sort), both halves are solved and then merged; Binary Search is the widely-taught special case where dividing narrows the problem down to exactly one surviving half each time, so nothing needs to be combined afterward — and this halve-and-recurse structure is exactly why standard algorithms curricula still classify it under Divide and Conquer, distinct from Greedy's incremental locally-optimal choices and Dynamic Programming's reuse of overlapping subproblem results.

Application: Binary Search follows this directly: at every step it divides the current search interval at its middle index, conquers by comparing the target against the middle element and keeping only the half that can still contain it, and repeats on the surviving half. Trace it on the sorted array [2, 4, 6, 8, 10, 12, 14] while searching for 12:

1. Divide: with low = 0 and high = 6, the middle index is mid = 3, so the array element there is 8.

2. Conquer: since 12 is greater than 8, the target cannot lie in the left half, so that half (indices 0 to 3) is dropped and the search continues only with low = 4, high = 6.

3. Divide again: the new middle index is mid = 5, and the element there is 12.

4. Conquer: the middle element matches the target, so the search terminates and returns index 5 — no separate combine step was needed because only one surviving half was ever carried forward.

Cross-check: This structure rules out the other paradigms offered. It is not Brute Force, because no sequential element-by-element scan of the whole array ever happens — a chunk of the array is dropped, unexamined, at every step. It is not Greedy, because there is no incremental build-up of a solution from a sequence of locally-optimal picks. And it is not Dynamic Programming, because each step narrows to a single smaller interval that is never revisited afterward — there are no overlapping subproblems whose results need to be memoized or reused. Only the divide-drop-recurse pattern above matches Divide and Conquer.