K Closest Elements in a Sorted Array

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

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

Examples
Example 1
arr = [-10,-4,-1,3,8,12]
k = 4
x = 2
return = [-4,-1,3,8]
Values -4 and 8 are equally distant from 2; the smaller value wins the boundary tie.
Example 2
arr = [2,4,6,8]
k = 1
x = 5
return = [4]
Values 4 and 6 are both one unit away, so the smaller value 4 is selected.
Example 3
arr = [5,6,7]
k = 2
x = 100
return = [6,7]
The target lies to the right of every array value, so the last two values are closest.

Constraints
1 <= arr.length <= 100000.
1 <= k <= arr.length.
arr is sorted in nondecreasing order.
-1000000000 <= arr[i], x <= 1000000000.

The trick: the k closest values always form a contiguous window in a sorted array. So you only need the window's left index, somewhere in 0 to n-k. Binary search on that index. For a candidate left index mid, compare x - arr[mid] with arr[mid+k] - x. If x - arr[mid] is larger, the window should move right, so left = mid+1. Otherwise right = mid. The tie rule favors the smaller value, which is why equal distances keep the left side. Use a strict greater-than check and you get it right. The common pitfall is the two-pointer shrink, which is O(n) and fine here but easy to botch on ties. Another is sorting by distance, which costs O(n log n) and needs a re-sort to ascending. Values reach 1e9, so differences fit in 32-bit ints only barely. Use longs if you're unsure. If the binary search logic slips mid-assessment, StealthCoder is the hedge that gives you the working version live.

The honest play: practice the pattern, and have StealthCoder ready for the one you didn't see coming.