# Solving Leetcode Interviews in Seconds with AI: Frequency Tracker


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2671" 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
	> Design a data structure that keeps track of the values in it and answers some queries regarding their frequencies. Implement the FrequencyTracker class.  FrequencyTracker(): Initializes the FrequencyTracker object with an empty array initially. void add(int number): Adds number to the data structure. void deleteOne(int number): Deletes one occurrence of number from the data structure. The data structure may not contain number, and in this case nothing is deleted. bool hasFrequency(int frequency): Returns true if there is a number in the data structure that occurs frequency number of times, otherwise, it returns false.    Example 1:  Input ["FrequencyTracker", "add", "add", "hasFrequency"] [[], [3], [3], [2]] Output [null, null, null, true]  Explanation FrequencyTracker frequencyTracker = new FrequencyTracker(); frequencyTracker.add(3); // The data structure now contains [3] frequencyTracker.add(3); // The data structure now contains [3, 3] frequencyTracker.hasFrequency(2); // Returns true, because 3 occurs twice   Example 2:  Input ["FrequencyTracker", "add", "deleteOne", "hasFrequency"] [[], [1], [1], [1]] Output [null, null, null, false]  Explanation FrequencyTracker frequencyTracker = new FrequencyTracker(); frequencyTracker.add(1); // The data structure now contains [1] frequencyTracker.deleteOne(1); // The data structure becomes empty [] frequencyTracker.hasFrequency(1); // Returns false, because the data structure is empty   Example 3:  Input ["FrequencyTracker", "hasFrequency", "add", "hasFrequency"] [[], [2], [3], [1]] Output [null, false, null, true]  Explanation FrequencyTracker frequencyTracker = new FrequencyTracker(); frequencyTracker.hasFrequency(2); // Returns false, because the data structure is empty frequencyTracker.add(3); // The data structure now contains [3] frequencyTracker.hasFrequency(1); // Returns true, because 3 occurs once     Constraints:  1 <= number <= 105 1 <= frequency <= 105 At most, 2 * 105 calls will be made to add, deleteOne, and hasFrequency in total.  

	# Explanation
	Here's a breakdown of the approach, complexity, and the Python code for the `FrequencyTracker` data structure:

*   **High-Level Approach:**

    *   Use a dictionary (`counts`) to store the frequency of each number in the data structure. This allows for O(1) access to the count of any number.
    *   Use another dictionary (`frequencies`) to store the count of each frequency. `frequencies[f]` stores the number of numbers with frequency `f`. This is used to efficiently check if any number has a certain frequency.
*   **Complexity:**
    *   Runtime: O(1) for `add`, `deleteOne`, and `hasFrequency`.
    *   Storage: O(N) where N is the number of unique elements inserted.

	
	# Code
	```python
	class FrequencyTracker:

    def __init__(self):
        self.counts = {}  # number -> frequency
        self.frequencies = {}  # frequency -> count of numbers with that frequency

    def add(self, number: int) -> None:
        if number in self.counts:
            old_frequency = self.counts[number]
            self.frequencies[old_frequency] -= 1
            if self.frequencies[old_frequency] == 0:
                del self.frequencies[old_frequency]

            self.counts[number] += 1
            new_frequency = self.counts[number]
            self.frequencies[new_frequency] = self.frequencies.get(new_frequency, 0) + 1

        else:
            self.counts[number] = 1
            self.frequencies[1] = self.frequencies.get(1, 0) + 1

    def deleteOne(self, number: int) -> None:
        if number in self.counts:
            old_frequency = self.counts[number]
            self.frequencies[old_frequency] -= 1
            if self.frequencies[old_frequency] == 0:
                del self.frequencies[old_frequency]

            if self.counts[number] == 1:
                del self.counts[number]
            else:
                self.counts[number] -= 1
                new_frequency = self.counts[number]
                self.frequencies[new_frequency] = self.frequencies.get(new_frequency, 0) + 1

    def hasFrequency(self, frequency: int) -> bool:
        return frequency in self.frequencies
	```