Find K Closest Elements in a Sorted Array

Given a sorted integer array arr, an integer k, and a target x, return the k closest values to x in ascending order.
A value a is closer than b when |a - x| < |b - x|. For equal distances, the smaller value is closer.

Function
findClosestElements(arr: int[], k: int, x: int) → int[]

Examples
Example 1
arr = [1,2,3,4,5]
k = 4
x = 3
return = [1,2,3,4]
The four smallest distances belong to 1, 2, 3, and 4.
Example 2
arr = [1,2,3,4,5]
k = 4
x = -1
return = [1,2,3,4]
The target lies left of the array, so the first four values are closest.

Constraints
arr is non-empty and sorted in nondecreasing order.
1 <= k <= arr.length.
All values and x are signed integers.

The trick: the k closest elements always form a contiguous block of length k. So binary search the left edge of that block over the range 0 to n-k. At mid, compare the two candidates at the boundary: x - arr[mid] versus arr[mid+k] - x. If x - arr[mid] is greater, the window should shift right, so set lo = mid+1. Otherwise set hi = mid. Return arr[lo:lo+k]. That's O(log(n-k) + k). The common pitfall is the tie-break. On equal distance the smaller value wins, so use a strict greater-than when shifting right. Another trap is searching up to n instead of n-k, which causes an out-of-bounds read on arr[mid+k]. Sorting by distance with a custom comparator also works but costs O(n log n) and ignores the sorted input. Keep the final slice in ascending order. StealthCoder is your hedge if the boundary comparison slips your mind mid-assessment.

StealthCoder is the hedge for the one pattern you didn't drill. It runs invisibly during the screen share.