# Solving Leetcode Interviews in Seconds with AI: Finding Pairs With a Certain Sum


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1865" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> You are given two integer arrays nums1 and nums2. You are tasked to implement a data structure that supports queries of two types:  Add a positive integer to an element of a given index in the array nums2. Count the number of pairs (i, j) such that nums1[i] + nums2[j] equals a given value (0 <= i < nums1.length and 0 <= j < nums2.length).  Implement the FindSumPairs class:  FindSumPairs(int[] nums1, int[] nums2) Initializes the FindSumPairs object with two integer arrays nums1 and nums2. void add(int index, int val) Adds val to nums2[index], i.e., apply nums2[index] += val. int count(int tot) Returns the number of pairs (i, j) such that nums1[i] + nums2[j] == tot.    Example 1:  Input ["FindSumPairs", "count", "add", "count", "count", "add", "add", "count"] [[[1, 1, 2, 2, 2, 3], [1, 4, 5, 2, 5, 4]], [7], [3, 2], [8], [4], [0, 1], [1, 1], [7]] Output [null, 8, null, 2, 1, null, null, 11]  Explanation FindSumPairs findSumPairs = new FindSumPairs([1, 1, 2, 2, 2, 3], [1, 4, 5, 2, 5, 4]); findSumPairs.count(7);  // return 8; pairs (2,2), (3,2), (4,2), (2,4), (3,4), (4,4) make 2 + 5 and pairs (5,1), (5,5) make 3 + 4 findSumPairs.add(3, 2); // now nums2 = [1,4,5,4,5,4] findSumPairs.count(8);  // return 2; pairs (5,2), (5,4) make 3 + 5 findSumPairs.count(4);  // return 1; pair (5,0) makes 3 + 1 findSumPairs.add(0, 1); // now nums2 = [2,4,5,4,5,4] findSumPairs.add(1, 1); // now nums2 = [2,5,5,4,5,4] findSumPairs.count(7);  // return 11; pairs (2,1), (2,2), (2,4), (3,1), (3,2), (3,4), (4,1), (4,2), (4,4) make 2 + 5 and pairs (5,3), (5,5) make 3 + 4    Constraints:  1 <= nums1.length <= 1000 1 <= nums2.length <= 105 1 <= nums1[i] <= 109 1 <= nums2[i] <= 105 0 <= index < nums2.length 1 <= val <= 105 1 <= tot <= 109 At most 1000 calls are made to add and count each.  

	# Explanation
	Here's a breakdown of the approach and the Python code:

*   **High-Level Approach:**
    *   Use a hash map (dictionary in Python) to store the frequencies of elements in `nums2`. This allows for efficient counting of occurrences.
    *   When `add(index, val)` is called, update `nums2` and adjust the frequencies in the hash map accordingly.
    *   When `count(tot)` is called, iterate through `nums1` and check how many elements in `nums2` can sum up to `tot` using the frequency information from the hash map.

*   **Complexity:**
    *   Runtime: `O(n)` for initialization, `O(1)` for `add`, `O(m)` for `count` (where `n` is the length of `nums2` and `m` is the length of `nums1`).
    *   Storage: `O(n)` to store the frequency map of `nums2`.

	
	# Code
	```python
	class FindSumPairs:

    def __init__(self, nums1: list[int], nums2: list[int]):
        self.nums1 = nums1
        self.nums2 = nums2
        self.freq = {}
        for num in nums2:
            self.freq[num] = self.freq.get(num, 0) + 1

    def add(self, index: int, val: int) -> None:
        old_val = self.nums2[index]
        self.freq[old_val] -= 1
        if self.freq[old_val] == 0:
            del self.freq[old_val]

        self.nums2[index] += val
        new_val = self.nums2[index]
        self.freq[new_val] = self.freq.get(new_val, 0) + 1

    def count(self, tot: int) -> int:
        count = 0
        for num in self.nums1:
            complement = tot - num
            if complement in self.freq:
                count += self.freq[complement]
        return count
	```