Подмассив с суммой K

public class Solution
{
    public static int CountSubarrays(List<int> nums, int targetSum)
    {
        var prefixSums = new Dictionary<int, int> { { 0, 1 } };
        int currentPrefixSum = 0;
        int count = 0;

        foreach (int el in nums)
        {
            currentPrefixSum += el;
            // Если встречали префиксную сумму current - target,
            //  значит между ними подмассив с нужной суммой
            if (prefixSums.TryGetValue(currentPrefixSum - targetSum, out int val))
            {
                count += val;
            }
            if (!prefixSums.ContainsKey(currentPrefixSum))
            {
                prefixSums[currentPrefixSum] = 0;
            }
            prefixSums[currentPrefixSum]++;
        }

        return count;
    }
}

#include <vector>
#include <unordered_map>

using namespace std;

int countSubarrays(const vector<int>& nums, int targetSum) {
    unordered_map<int, int> prefixSums;
    prefixSums[0] = 1;
    int currentPrefixSum = 0;
    int count = 0;

    for (int el : nums) {
        currentPrefixSum += el;
        // если встречали префиксную сумму current - target,
        //  значит между ними подмассив с нужной суммой
        if (prefixSums.count(currentPrefixSum - targetSum)) {
            count += prefixSums[currentPrefixSum - targetSum];
        }
        prefixSums[currentPrefixSum]++;
    }
    return count;
}

package main

func countSubarrays(nums []int, targetSum int) int {
    prefixSums := map[int]int{0: 1}
    currentPrefixSum := 0
    count := 0

    for _, el := range nums {
        currentPrefixSum += el
        // если встречали префиксную сумму current - target,
        //  значит между ними подмассив с нужной суммой
        count += prefixSums[currentPrefixSum-targetSum]
        prefixSums[currentPrefixSum]++
    }

    return count
}

import java.util.*;

public class Solution {
    public int countSubarrays(List<Integer> nums, int targetSum) {
        Map<Integer, Integer> prefixSums = new HashMap<>();
        prefixSums.put(0, 1);
        int currentPrefixSum = 0;
        int count = 0;

        for (int el : nums) {
            currentPrefixSum += el;
            // если встречали префиксную сумму current - target,
            //  значит между ними подмассив с нужной суммой
            count += prefixSums.getOrDefault(currentPrefixSum - targetSum, 0);
            prefixSums.put(currentPrefixSum, prefixSums.getOrDefault(currentPrefixSum, 0) + 1);
        }

        return count;
    }
}

from typing import *

def count_subarrays(nums: List[int], target_sum: int) -> int:
    prefix_sums = {0: 1}
    current_prefix_sum = 0
    count = 0

    for el in nums:
        current_prefix_sum += el
        # если встречали префиксную сумму current - target,
        #  значит между ними подмассив с нужной суммой
        count += prefix_sums.get(current_prefix_sum - target_sum, 0)
        prefix_sums[current_prefix_sum] = prefix_sums.get(current_prefix_sum, 0) + 1

    return count

/**
 * @param {number[]} nums
 * @param {number} targetSum
 * @returns {number}
 */
export function countSubarrays(nums, targetSum) {
  const prefixSums = {0: 1};
  let currentPrefixSum = 0;
  let count = 0;

  for (const el of nums) {
    currentPrefixSum += el;
    // если встречали префиксную сумму current - target,
    //  значит между ними подмассив с нужной суммой
    count += prefixSums[currentPrefixSum - targetSum] || 0;
    prefixSums[currentPrefixSum] = (prefixSums[currentPrefixSum] || 0) + 1;
  }

  return count;
}