# Solving Leetcode Interviews in Seconds with AI: Closest Room


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1847" 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
	> There is a hotel with n rooms. The rooms are represented by a 2D integer array rooms where rooms[i] = [roomIdi, sizei] denotes that there is a room with room number roomIdi and size equal to sizei. Each roomIdi is guaranteed to be unique. You are also given k queries in a 2D array queries where queries[j] = [preferredj, minSizej]. The answer to the jth query is the room number id of a room such that:  The room has a size of at least minSizej, and abs(id - preferredj) is minimized, where abs(x) is the absolute value of x.  If there is a tie in the absolute difference, then use the room with the smallest such id. If there is no such room, the answer is -1. Return an array answer of length k where answer[j] contains the answer to the jth query.   Example 1:  Input: rooms = [[2,2],[1,2],[3,2]], queries = [[3,1],[3,3],[5,2]] Output: [3,-1,3] Explanation: The answers to the queries are as follows: Query = [3,1]: Room number 3 is the closest as abs(3 - 3) = 0, and its size of 2 is at least 1. The answer is 3. Query = [3,3]: There are no rooms with a size of at least 3, so the answer is -1. Query = [5,2]: Room number 3 is the closest as abs(3 - 5) = 2, and its size of 2 is at least 2. The answer is 3. Example 2:  Input: rooms = [[1,4],[2,3],[3,5],[4,1],[5,2]], queries = [[2,3],[2,4],[2,5]] Output: [2,1,3] Explanation: The answers to the queries are as follows: Query = [2,3]: Room number 2 is the closest as abs(2 - 2) = 0, and its size of 3 is at least 3. The answer is 2. Query = [2,4]: Room numbers 1 and 3 both have sizes of at least 4. The answer is 1 since it is smaller. Query = [2,5]: Room number 3 is the only room with a size of at least 5. The answer is 3.   Constraints:  n == rooms.length 1 <= n <= 105 k == queries.length 1 <= k <= 104 1 <= roomIdi, preferredj <= 107 1 <= sizei, minSizej <= 107  

	# Explanation
	Here's the solution, explained as requested:

*   **Sort and Filter:** Sort the rooms by size in descending order. For each query, filter the rooms to keep only those with sizes greater than or equal to the query's `minSize`.

*   **Binary Search for Nearest Room:** After filtering, find the room ID closest to the query's `preferred` value. This can be done efficiently using binary search since the room IDs will be implicitly sorted after filtering using the original room ID order.

*   **Handle No Match:** If no room satisfies the size constraint, return -1.

*   **Runtime & Storage Complexity:**
    *   **Runtime:** O(n log n + k log n), where n is the number of rooms and k is the number of queries. The n log n comes from sorting the rooms initially.  Each query involves filtering (which can be optimized to be linear with the sorted rooms), and then at worst a binary search (log n).
    *   **Storage:** O(n), mainly for storing the sorted rooms.

	
	# Code
	```python
	def solve():
    def closest_room(rooms, preferred, minSize):
        eligible_rooms = []
        for room_id, size in rooms:
            if size >= minSize:
                eligible_rooms.append(room_id)
        
        if not eligible_rooms:
            return -1

        best_room = -1
        min_diff = float('inf')

        for room_id in eligible_rooms:
            diff = abs(room_id - preferred)
            if diff < min_diff:
                min_diff = diff
                best_room = room_id
            elif diff == min_diff:
                best_room = min(best_room, room_id)

        return best_room

    rooms = [[2,2],[1,2],[3,2]]
    queries = [[3,1],[3,3],[5,2]]
    
    # rooms = [[1,4],[2,3],[3,5],[4,1],[5,2]]
    # queries = [[2,3],[2,4],[2,5]]


    n = len(rooms)
    k = len(queries)

    rooms.sort(key=lambda x: x[1], reverse=True)  # Sort rooms by size descending

    answers = []
    for preferred, minSize in queries:
        answers.append(closest_room(rooms, preferred, minSize))

    print(answers)

solve()
	```