Airbnb Interview Questions

Building a modern socially-influenced experience for Airbnb is vital to trawl through user-generated content from experiences (such as reviews and photos). This involves creating a class-based structure for managing a user's feed aligned with their interests.
Problem statement: implement a class to handle a simple Twitter-like feed that allows users to create a post, display the feed, and follow other users.
- class TwitterFeed:
- def __init__(self): - Initializes the object.
- def post(self, user_id: int, post: str): - Creates a new post for the specified user.
- def follow(self, follower_id:int, followee_id:int): - Allows one user to follow another.
- def get_feed(self, user_id: int) -> List[str]: - Retrieve the latest n posts from followed users.Example 1:
Input:
twitter = TwitterFeed()
twitter.post(1, "Looking for cozy places in Paris!")
twitter.post(2, "Trying out local cuisine.")
twitter.follow(1, 2)
print(twitter.get_feed(1)) // returns ["Trying out local cuisine."]Example 2:
Input:
twitter.follow(1, 3)
print(twitter.get_feed(1)) // returns [] since user 3 has no posts.Constraints:
- 1 <= user_id <= 10^4
- posts per user = 100
- followed users = 50

Airbnb needs to optimize its API by implementing a caching mechanism for property listings to reduce database load and improve response time.
Problem statement: Implement an LRU (Least Recently Used) cache with a specified capacity. The cache should support get(key) and put(key, value) operations.
- class LRUCache:
- def __init__(self, capacity: int): - Initializes the LRUCache with the maximum capacity.
- def get(self, key: int) -> int: - Returns the value of the key if the key exists in the cache, otherwise return -1.
- def put(self, key: int, value: int): - Update the value of the key if it exists, otherwise add the key-value pair to the cache. When the cache reaches its capacity, it should invalidate the least recently used item before inserting a new item.Example 1:
Input:
cache = LRUCache(2)
cache.put(1, 1)
cache.put(2, 2)
cache.get(1) // returns 1
cache.put(3, 3) // evicts key 2
cache.get(2) // returns -1 (not found)Example 2:
Input:
cache.put(4, 4) // evicts key 1
cache.get(1) // returns -1 (not found)
cache.get(3) // returns 3
cache.get(4) // returns 4Constraints:
- 1 <= capacity <= 3000
- 0 <= key <= 10^4
- 0 <= value <= 10^4

Users often look for homes to rent on specific datetime ranges, and it's essential to efficiently check if the rental is available for the requested dates.
Problem statement: Given a list of rental_id with their corresponding availability ranges in the form of pairs (start_date, end_date) and a queried date range, return a list of rental IDs that are available during the entire period of the query.
- def search_available_rentals(rentals: List[Tuple[int, Tuple[int, int]]], query: Tuple[int, int]) -> List[int]: - Returns rental IDs that are available for the entire query date range.Example 1:
Input: rentals = [(1, (1, 5)), (2, (2, 6)), (3, (5, 10))], query = (3, 4)
Output: [1, 3]
Explanation: Rentals 1 (1 to 5) and 3 (5 to 10) are available in the range of 3 to 4.Example 2:
Input: rentals = [(1, (1, 5)), (2, (6, 10)), (3, (5, 10))], query = (2, 4)
Output: [1]
Explanation: Only Rental 1 is available during the queried dates.Constraints:
- 1 <= rentals.length <= 10^4
- 1 <= rental_id <= 10^6
- 1 <= start_date < end_date <= 10^6
- 1 <= query[0] < query[1] <= 10^6

In a platform like Airbnb, it's crucial to find neighboring properties efficiently to help users browse similar options. This will enhance the user experience by showing related listings when a user views a particular property.
Problem statement: You need to implement a function that takes a list of properties represented as nodes in a graph and returns a list of all neighboring properties within a certain distance. Each node has a property_id and a list of neighbors (i.e., directly connected properties).
- def find_neighbors(properties: List[Property], id: int, distance: int) -> List[int]: - Returns the list of property identifiers of neighboring properties within the specified distance.Example 1:
Input: properties = [[1, [2, 3]], [2, [1, 4]], [3, [1]], [4, [2]]], id = 1, distance = 1
Output: [2, 3]
Explanation: Property 1 is directly connected to properties 2 and 3.Example 2:
Input: properties = [[1, [2, 3]], [2, [1, 4]], [3, [1]], [4, [2]]], id = 1, distance = 2
Output: [2, 3, 4]
Explanation: Property 1 is connected to properties 2 and 3 directly, and property 2 connects to property 4.Constraints:
- 1 <= properties.length <= 1000
- 1 <= property_id <= 10^6
- 0 <= distance <= 50