# Solving Leetcode Interviews in Seconds with AI: Kth Largest Element in a Stream


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "703" 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 part of a university admissions office and need to keep track of the kth highest test score from applicants in real-time. This helps to determine cut-off marks for interviews and admissions dynamically as new applicants submit their scores. You are tasked to implement a class which, for a given integer k, maintains a stream of test scores and continuously returns the kth highest test score after a new score has been submitted. More specifically, we are looking for the kth highest score in the sorted list of all scores. Implement the KthLargest class:  KthLargest(int k, int[] nums) Initializes the object with the integer k and the stream of test scores nums. int add(int val) Adds a new test score val to the stream and returns the element representing the kth largest element in the pool of test scores so far.    Example 1:  Input: ["KthLargest", "add", "add", "add", "add", "add"] [[3, [4, 5, 8, 2]], [3], [5], [10], [9], [4]] Output: [null, 4, 5, 5, 8, 8] Explanation: KthLargest kthLargest = new KthLargest(3, [4, 5, 8, 2]); kthLargest.add(3); // return 4 kthLargest.add(5); // return 5 kthLargest.add(10); // return 5 kthLargest.add(9); // return 8 kthLargest.add(4); // return 8  Example 2:  Input: ["KthLargest", "add", "add", "add", "add"] [[4, [7, 7, 7, 7, 8, 3]], [2], [10], [9], [9]] Output: [null, 7, 7, 7, 8] Explanation: KthLargest kthLargest = new KthLargest(4, [7, 7, 7, 7, 8, 3]); kthLargest.add(2); // return 7 kthLargest.add(10); // return 7 kthLargest.add(9); // return 7 kthLargest.add(9); // return 8   Constraints:  0 <= nums.length <= 104 1 <= k <= nums.length + 1 -104 <= nums[i] <= 104 -104 <= val <= 104 At most 104 calls will be made to add.  

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

*   **Key Approach:**
    *   Use a min-heap (priority queue) to store the *k* largest elements seen so far.
    *   When a new element is added: If the heap size is less than *k*, add the element. Otherwise, if the element is greater than the smallest element in the heap, remove the smallest element and add the new element.
    *   The root of the min-heap will always be the *k*th largest element.

*   **Complexity:**
    *   Runtime: O(log *k*) for each `add` operation. O(nlogk) to initialize the KthLargest object with n elements, where n is the size of nums.
    *   Storage: O(*k*) to store the heap.

	
	# Code
	```python
	import heapq

class KthLargest:

    def __init__(self, k: int, nums: list[int]):
        self.k = k
        self.heap = []
        for num in nums:
            self.add(num)

    def add(self, val: int) -> int:
        if len(self.heap) < self.k:
            heapq.heappush(self.heap, val)
        elif val > self.heap[0]:
            heapq.heapreplace(self.heap, val)
        return self.heap[0]
	```