1658. Minimum Operations to Reduce X to Zero

class Solution {
    public int minOperations(int[] nums, int x) {
        int total = 0;
        for (int num : nums) total += num;
        int target = total - x;
        if (target < 0) return -1;
        if (target == 0) return nums.length;
        int maxLen = -1;
        int windowSum = 0;
        int left = 0;
        for (int right = 0; right < nums.length; right++) {
            windowSum += nums[right];
            while (windowSum > target && left <= right) {
                windowSum -= nums[left];
                left++;
            }
            if (windowSum == target) {
                maxLen = Math.max(maxLen, right - left + 1);
            }
        }
        return maxLen == -1 ? -1 : nums.length - maxLen;
    }
}

class Solution:
    def minOperations(self, nums, x):
        total = sum(nums)
        target = total - x

        if target < 0:
            return -1

        if target == 0:
            return len(nums)

        max_len = -1
        window_sum = 0
        left = 0

        for right in range(len(nums)):
            window_sum += nums[right]

            while window_sum > target and left <= right:
                window_sum -= nums[left]
                left += 1

            if window_sum == target:
                max_len = max(max_len, right - left + 1)

        return -1 if max_len == -1 else len(nums) - max_len

class Solution {
public:
    int minOperations(vector<int>& nums, int x) {
        int total = 0;

        for (int num : nums)
            total += num;

        int target = total - x;

        if (target < 0)
            return -1;

        if (target == 0)
            return nums.size();

        int maxLen = -1;
        int windowSum = 0;
        int left = 0;

        for (int right = 0; right < nums.size(); right++) {
            windowSum += nums[right];

            while (windowSum > target && left <= right) {
                windowSum -= nums[left];
                left++;
            }

            if (windowSum == target) {
                maxLen = max(maxLen, right - left + 1);
            }
        }

        return maxLen == -1 ? -1 : nums.size() - maxLen;
    }
};

class Solution {
    minOperations(nums, x) {
        let total = 0;

        for (const num of nums) {
            total += num;
        }

        const target = total - x;

        if (target < 0) {
            return -1;
        }

        if (target === 0) {
            return nums.length;
        }

        let maxLen = -1;
        let windowSum = 0;
        let left = 0;

        for (let right = 0; right < nums.length; right++) {
            windowSum += nums[right];

            while (windowSum > target && left <= right) {
                windowSum -= nums[left];
                left++;
            }

            if (windowSum === target) {
                maxLen = Math.max(
                    maxLen,
                    right - left + 1
                );
            }
        }

        return maxLen === -1
            ? -1
            : nums.length - maxLen;
    }
}