feat: solve booking closest hotel problem

Author: empeje

packages/problems-repository/booking_com_closest_hotels.md

@@ -0,0 +1,129 @@
+# Booking.com Closest Hotels
+
+## Problem Description
+
+You are tasked with implementing a system to find the K closest hotels from a given starting point for Booking.com's hotel search feature. The system should efficiently process hotel locations and return the nearest hotels based on geographical distance.
+
+### Input Format
+
+The system receives:
+1. A list of hotels with their coordinates and metadata
+2. A starting point (latitude, longitude)
+3. An integer K representing the number of closest hotels to find
+
+```json
+{
+  "hotels": [
+    {
+      "hotel_id": "H1",
+      "name": "Grand Hotel",
+      "latitude": 52.3676,
+      "longitude": 4.9041,
+      "rating": 4.5,
+      "price_per_night": 150.00,
+      "amenities": ["wifi", "pool", "gym"]
+    },
+    {
+      "hotel_id": "H2",
+      "name": "Seaside Resort",
+      "latitude": 52.3702,
+      "longitude": 4.8952,
+      "rating": 4.2,
+      "price_per_night": 200.00,
+      "amenities": ["wifi", "beach", "restaurant"]
+    }
+    // ... more hotels
+  ],
+  "start_point": {
+    "latitude": 52.3670,
+    "longitude": 4.9010
+  },
+  "k": 5
+}
+```
+
+### Requirements
+
+1. Implement a function that returns the K closest hotels to the starting point, sorted by distance.
+2. The solution should be efficient for large datasets (millions of hotels).
+3. Consider additional factors that might affect hotel selection:
+   - Hotel rating
+   - Price per night
+   - Available amenities
+   - Current availability
+
+4. Handle edge cases:
+   - Multiple hotels at the same distance
+   - Invalid coordinates
+   - Empty hotel list
+   - K larger than the number of available hotels
+   - Hotels with missing or invalid data
+
+### Additional Scenarios to Consider
+
+1. How would you handle real-time updates to hotel availability?
+2. What if users want to filter results by price range or amenities?
+3. How would you implement caching for frequently searched locations?
+4. How would you handle different distance metrics (e.g., walking distance vs. straight-line distance)?
+5. What if you need to consider traffic conditions or transportation options?
+
+### Technical Requirements
+
+1. Write code that efficiently finds the K closest hotels
+2. Explain the runtime complexity of your solution
+3. Suggest optimizations for handling large datasets
+4. Consider how to make the system scalable for future requirements
+
+### Example Output
+
+```json
+{
+  "closest_hotels": [
+    {
+      "hotel_id": "H1",
+      "name": "Grand Hotel",
+      "distance": 0.3,  // in kilometers
+      "rating": 4.5,
+      "price_per_night": 150.00,
+      "amenities": ["wifi", "pool", "gym"]
+    },
+    {
+      "hotel_id": "H2",
+      "name": "Seaside Resort",
+      "distance": 0.5,
+      "rating": 4.2,
+      "price_per_night": 200.00,
+      "amenities": ["wifi", "beach", "restaurant"]
+    }
+    // ... more hotels up to K
+  ],
+  "search_metadata": {
+    "total_hotels_considered": 1000,
+    "search_time_ms": 45,
+    "radius_covered_km": 2.5
+  }
+}
+```
+
+### Evaluation Criteria
+
+1. Algorithm efficiency and correctness
+2. Code quality and organization
+3. Handling of edge cases
+4. Runtime complexity analysis
+5. Scalability considerations
+6. Additional features implemented
+7. Problem-solving approach
+
+### Notes
+
+- The Earth's curvature should be considered when calculating distances
+- The solution should be optimized for both time and space complexity
+- Consider using appropriate data structures for efficient nearest neighbor searches
+- The system should be able to handle frequent updates to hotel data
+- Think about how to make the solution maintainable and extensible
+
+### Source
+
+This problem is based on a real Booking.com interview experience:
+https://leetcode.com/discuss/post/1395715/bookingcom-backend-developer-amsterdam-j-cm4f/ 

packages/python-exercise/python_exercise/closest_hotels.py

@@ -0,0 +1,154 @@
+from dataclasses import dataclass
+from typing import List, Dict, Optional, Set, Tuple, Any, NoReturn
+import math
+from collections import defaultdict
+
+
+@dataclass
+class Point:
+    latitude: float
+    longitude: float
+
+
+@dataclass
+class Hotel:
+    hotel_id: str
+    name: str
+    latitude: float
+    longitude: float
+    rating: float
+    price_per_night: float
+    amenities: List[str]
+
+
+class ClosestHotelsFinder:
+    def __init__(self) -> None:
+        self.hotels: List[Hotel] = []
+        self._rtree = None  # Placeholder for R-tree implementation
+
+    def add_hotel(self, hotel_data: Dict) -> None:
+        """Add a hotel to the finder."""
+        try:
+            hotel = Hotel(**hotel_data)
+            self._validate_coordinates(hotel.latitude, hotel.longitude)
+            self.hotels.append(hotel)
+        except (TypeError, ValueError) as e:
+            raise ValueError(f"Invalid hotel data: {str(e)}")
+
+    def _validate_coordinates(self, latitude: float, longitude: float) -> None:
+        """Validate that coordinates are within valid ranges."""
+        if not (-90 <= latitude <= 90):
+            raise ValueError(f"Invalid latitude: {latitude}")
+        if not (-180 <= longitude <= 180):
+            raise ValueError(f"Invalid longitude: {longitude}")
+
+    def _calculate_distance(self, point1: Point, point2: Point) -> float:
+        """Calculate the Haversine distance between two points in kilometers."""
+        # Earth's radius in kilometers
+        R = 6371.0
+
+        lat1, lon1 = math.radians(point1.latitude), math.radians(point1.longitude)
+        lat2, lon2 = math.radians(point2.latitude), math.radians(point2.longitude)
+
+        dlat = lat2 - lat1
+        dlon = lon2 - lon1
+
+        a = math.sin(dlat / 2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2)**2
+        c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
+
+        return R * c
+
+    def find_closest_hotels(
+        self,
+        start_point: Dict[str, float],
+        k: int,
+        filters: Optional[Dict] = None
+    ) -> Dict[str, Any]:
+        """Find the K closest hotels to the starting point."""
+        if not self.hotels:
+            return {
+                "closest_hotels": [],
+                "search_metadata": {
+                    "total_hotels_considered": 0,
+                    "search_time_ms": 0,
+                    "radius_covered_km": 0
+                }
+            }
+
+        try:
+            start = Point(**start_point)
+            self._validate_coordinates(start.latitude, start.longitude)
+        except (TypeError, ValueError) as e:
+            raise ValueError(f"Invalid start point: {str(e)}")
+
+        if k <= 0:
+            raise ValueError("K must be a positive integer")
+
+        # Apply filters if provided
+        filtered_hotels = self._apply_filters(self.hotels, filters)
+
+        # Calculate distances and sort
+        hotels_with_distances = []
+        for hotel in filtered_hotels:
+            hotel_point = Point(latitude=hotel.latitude, longitude=hotel.longitude)
+            distance = self._calculate_distance(start, hotel_point)
+            hotels_with_distances.append((hotel, distance))
+
+        # Sort by distance and take top K
+        hotels_with_distances.sort(key=lambda x: x[1])
+        closest_hotels = hotels_with_distances[:k]
+
+        # Prepare response
+        result = {
+            "closest_hotels": [
+                {
+                    "hotel_id": hotel.hotel_id,
+                    "name": hotel.name,
+                    "distance": round(distance, 2),
+                    "rating": hotel.rating,
+                    "price_per_night": hotel.price_per_night,
+                    "amenities": hotel.amenities
+                }
+                for hotel, distance in closest_hotels
+            ],
+            "search_metadata": {
+                "total_hotels_considered": len(filtered_hotels),
+                "search_time_ms": 0,  # Would be implemented with actual timing
+                "radius_covered_km": round(closest_hotels[-1][1], 2) if closest_hotels else 0
+            }
+        }
+
+        return result
+
+    def _apply_filters(self, hotels: List[Hotel], filters: Optional[Dict]) -> List[Hotel]:
+        """Apply filters to the hotel list."""
+        if not filters:
+            return hotels
+
+        filtered_hotels = hotels.copy()
+
+        if "min_rating" in filters:
+            filtered_hotels = [h for h in filtered_hotels if h.rating >= filters["min_rating"]]
+        
+        if "max_price" in filters:
+            filtered_hotels = [h for h in filtered_hotels if h.price_per_night <= filters["max_price"]]
+        
+        if "amenities" in filters:
+            required_amenities = set(filters["amenities"])
+            filtered_hotels = [
+                h for h in filtered_hotels 
+                if required_amenities.issubset(set(h.amenities))
+            ]
+
+        return filtered_hotels
+
+    def load_hotels_from_file(self, file_path: str) -> None:
+        """Load hotels from a JSON file."""
+        import json
+        try:
+            with open(file_path, 'r') as f:
+                data = json.load(f)
+                for hotel_data in data.get("hotels", []):
+                    self.add_hotel(hotel_data)
+        except (FileNotFoundError, json.JSONDecodeError) as e:
+            raise Exception(f"Error loading hotels: {str(e)}")

packages/python-exercise/python_exercise/permutations.py

@@ -1,6 +1,27 @@
 def permutations(nums):
+    """
+    Generate all possible permutations of the given list of numbers.
+    
+    This function uses a backtracking algorithm to generate all permutations:
+    1. We maintain a 'start' index that divides the array into two parts:
+       - Elements before 'start' are fixed in the current permutation
+       - Elements from 'start' onward are candidates for the next position
+    2. For each recursive call, we try all possible elements at the current position
+       by swapping the element at 'start' with each element from 'start' to the end
+    3. After each swap, we recursively generate permutations for the next position
+    4. After the recursive call, we swap back (backtrack) to restore the original order
+    5. When 'start' reaches the end of the array, we've completed a permutation and add it to results
+    
+    Args:
+        nums: A list of elements to permute
+        
+    Returns:
+        A list containing all possible permutations of the input list
+    """
     def backtrack(start):
         if start == len(nums):
+            # We've reached the end of the array, so we've completed a permutation
+            # Make a copy of the current state and add it to our results
             result.append(nums[:])
             return