# Solving Leetcode Interviews in Seconds with AI: Count Integers in Intervals


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2276" 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
	> Given an empty set of intervals, implement a data structure that can:  Add an interval to the set of intervals. Count the number of integers that are present in at least one interval.  Implement the CountIntervals class:  CountIntervals() Initializes the object with an empty set of intervals. void add(int left, int right) Adds the interval [left, right] to the set of intervals. int count() Returns the number of integers that are present in at least one interval.  Note that an interval [left, right] denotes all the integers x where left <= x <= right.   Example 1:  Input ["CountIntervals", "add", "add", "count", "add", "count"] [[], [2, 3], [7, 10], [], [5, 8], []] Output [null, null, null, 6, null, 8]  Explanation CountIntervals countIntervals = new CountIntervals(); // initialize the object with an empty set of intervals.  countIntervals.add(2, 3);  // add [2, 3] to the set of intervals. countIntervals.add(7, 10); // add [7, 10] to the set of intervals. countIntervals.count();    // return 6                            // the integers 2 and 3 are present in the interval [2, 3].                            // the integers 7, 8, 9, and 10 are present in the interval [7, 10]. countIntervals.add(5, 8);  // add [5, 8] to the set of intervals. countIntervals.count();    // return 8                            // the integers 2 and 3 are present in the interval [2, 3].                            // the integers 5 and 6 are present in the interval [5, 8].                            // the integers 7 and 8 are present in the intervals [5, 8] and [7, 10].                            // the integers 9 and 10 are present in the interval [7, 10].    Constraints:  1 <= left <= right <= 109 At most 105 calls in total will be made to add and count. At least one call will be made to count.  

	# Explanation
	Here's a breakdown of the solution:

*   **Interval Management:** The core idea is to store intervals in a sorted manner, allowing for efficient merging of overlapping intervals.  We'll use a sorted list to represent the intervals.

*   **Merging Intervals:** When a new interval is added, we iterate through the existing intervals to find overlaps. Overlapping intervals are merged into a single, larger interval.

*   **Efficient Counting:** To optimize the `count()` operation, we maintain a running total of the number of integers covered by the intervals. This count is updated whenever intervals are added or merged.

*   **Complexity:** O(n) for add, O(1) for count, where n is the number of intervals. Storage complexity is O(n).

	
	# Code
	```python
	class CountIntervals:
    def __init__(self):
        self.intervals = []
        self.count_val = 0

    def add(self, left: int, right: int) -> None:
        new_interval = [left, right]
        i = 0
        while i < len(self.intervals):
            interval = self.intervals[i]
            if new_interval[1] < interval[0]:
                break
            elif new_interval[0] > interval[1]:
                i += 1
                continue
            else:
                new_interval[0] = min(new_interval[0], interval[0])
                new_interval[1] = max(new_interval[1], interval[1])
                self.count_val -= (interval[1] - interval[0] + 1)
                self.intervals.pop(i)
            
        self.intervals.insert(i, new_interval)
        self.count_val += (new_interval[1] - new_interval[0] + 1)

    def count(self) -> int:
        return self.count_val
	```