Given an integer array `nums` and an integer `k`, return the number of contiguous (non-empty) subarrays whose elements sum to exactly `k`. A subarray is a contiguous slice of the array. Two subarrays at different start/end positions are counted separately even if their contents are identical. Your algorithm must run better than O(n^2). The intended solution uses prefix sums and a hash map: keep a running prefix sum `s` while scanning left to right, and for each position add the number of earlier prefix sums equal to `s - k` (initializing the count of prefix sum 0 to 1 so that subarrays starting at index 0 are counted). This is O(n) time and O(n) space. The approach naturally handles negative numbers and zeros (a sliding window would NOT, because the running sum is not monotonic). For very large arrays it stays linear, and the running/prefix sums should use a 64-bit integer type to avoid overflow when many large values accumulate. Example 1: nums = [1, 1, 1], k = 2 -> 2 (the subarrays [1,1] at indices 0-1 and 1-2). Example 2: nums = [1, 2, 3], k = 3 -> 2 (the subarrays [1,2] and [3]). Example 3: nums = [0, 0, 0], k = 0 -> 6 (every one of the C(3,2)+3 = 6 contiguous slices sums to 0).