Added longest range in list with sorting.

Author: matthaeusheer

cp_python/random_questions/calender.py renamed to cp_python/random_questions/calendar.py

@@ -1,5 +1,7 @@
 """
-For two calendars, find time periods to schedule a meeting. Each calendar is represented by a list of meetings, hence during those periods no meeting can be scheduled. Also, every calendar comes with bounds telling us the earliest and the latest we can schedule meetings.
+For two calendars, find time periods to schedule a meeting. Each calendar is represented by a list of meetings,
+hence during those periods no meeting can be scheduled. Also, every calendar comes with bounds telling us the earliest
+and the latest we can schedule meetings.
 
 sample input:
 # calendar one, meetings and bounds
@@ -13,45 +15,47 @@
 
 from typing import List, Optional
 
+
 class Time:
     def __init__(self, time_str: str):
         """Format or time_str assumed to be military: '15:30'."""
         self.time_str = time_str
-    
+
     @property
     def hour(self):
         return int(self.time_str.split(':')[0])
-    
+
     @property
     def minute(self):
         return int(self.time_str.split(':')[1])
-    
+
     def __gt__(self, other):
         if self.hour > other.hour:
             return True
         elif self.hour == other.hour:
             return self.minute > other.minute
         elif self.hour < other.hour:
             return False
-    
+
     def __eq__(self, other):
         return self.hour == other.hour and self.minute == other.minute
-    
+
     def _to_hour_min(self):
         return [int(item) for item in self.time_str.split(':')]
-    
+
     def __repr__(self):
         return f'Time({self.time_str})'
-        
+
+
 class Slot:
     def __init__(self, start: str, end: str):
         """Format of arguments assumed to be military: '15:30'."""
         self.start = Time(start)
         self.end = Time(end)
-    
+
     def __repr__(self):
         return f'{self.__class__.__name__}(start={self.start}, end={self.end})'
-    
+
     def find_overlap(self, other: 'Slot') -> Optional['Slot']:
         slot_ahead, slot_behind = sorted([self, other], key=lambda slot: slot.start)
         if slot_behind.start > slot_ahead.end:
@@ -62,12 +66,13 @@ def find_overlap(self, other: 'Slot') -> Optional['Slot']:
                 return Slot(mutual_slot_start, slot_behind.end)
             else:
                 return Slot(mutual_slot_start, slot_ahead.end)
-            
-    
+
+
 class Meeting(Slot):
     def __init__(self, start: str, end: str):
         super().__init__(start, end)
-    
+
+
 class Calendar:
     def __init__(self, meetings: List[Meeting] = None):
         self.meetings = meetings if meetings else []
@@ -83,7 +88,8 @@ def free_slots(self, day_bounds: Slot):
         if day_bounds.end > time_ptr:
             free_slots.append(Slot(time_ptr.time_str, day_bounds.end.time_str))
         return free_slots
-    
+
+
 def find_mutual_slots(cal1: Calendar, cal2: Calendar, bounds1: Slot, bounds2: Slot) -> List[Slot]:
     slots1, slots2 = cal1.free_slots(bounds1), cal2.free_slots(bounds2)
     mutual_slots = []
@@ -94,9 +100,10 @@ def find_mutual_slots(cal1: Calendar, cal2: Calendar, bounds1: Slot, bounds2: Sl
                 mutual_slots.append(overlap)
     return mutual_slots
 
+
 if __name__ == '__main__':
-    calendar_one = Calendar([Meeting('8:00', '9:30'), 
-                         Meeting('10:00', '14:00'),
+    calendar_one = Calendar([Meeting('8:00', '9:30'),
+                             Meeting('10:00', '14:00'),
                              Meeting('15:00', '15:30')])
     bounds_one = Slot("7:00", "17:30")
     calendar_two = Calendar([Meeting('9:00', '12:30')])

cp_python/random_questions/random_questions.py

@@ -1,5 +1,3 @@
-import unittest
-
 from data_structures.linked_list import LinkedList
 
 
@@ -100,7 +98,7 @@ def longest_range(arr: list) -> list:
     Idea
     ----
         1)  We could sort the array and then go through it and check for consecutive ranges easily.
-            However, sorting takes O(nlogn), n being len(arr), while space would be O(1)
+            However, sorting takes O(nlogn), n being len(arr), while space would be O(1) - see trivial below
         2)  We can store the whole arr in marked - hash table, initialized with False for every entry.
             Then we would go through the array and take each position as a starting point to explore ranges
             in both directions if this starting point has not been marked yet. We keep track of our longest
@@ -142,3 +140,34 @@ def longest_range(arr: list) -> list:
     return [largest_low, largest_high]
 
 
+def longest_range_with_sorting(arr: list) -> list:
+    """For problem description see longest_range."""
+    if len(arr) == 0:
+        return [None, None]
+
+    arr = sorted(arr)
+    largest_length = 1
+    low, high = arr[0], arr[0]
+
+    jumped = False
+    current_length = 1
+    current_low = low
+    current_high = high
+    for idx in range(len(arr) - 1):
+        if jumped:
+            current_length = 1
+            current_low = arr[idx]
+            current_high = arr[idx]
+            jumped = False
+        if arr[idx + 1] == arr[idx] + 1:
+            current_length += 1
+            current_high = arr[idx + 1]
+        else:
+            jumped = True
+        if jumped or idx + 1 == (len(arr) - 1):
+            if current_length > largest_length:
+                low = current_low
+                high = current_high
+                largest_length = current_length
+
+    return [low, high]

cp_python/tests/random_questions/test_random_questions.py

@@ -3,7 +3,7 @@
 from random_questions.random_questions import add_one_to_digit_list
 from random_questions.random_questions import reverse_linked_list, reverse_linked_list_2
 from random_questions.random_questions import schnecken_dist_travelled
-from random_questions.random_questions import longest_range
+from random_questions.random_questions import longest_range, longest_range_with_sorting
 from data_structures.linked_list import LinkedList
 from tests.test_utils import run_sub_tests
 
@@ -41,4 +41,5 @@ def test_longest_range(self):
         for test_idx, (in_arr, solution) in enumerate(test_cases):
             with self.subTest(test_idx=test_idx):
                 self.assertEqual(solution, longest_range(in_arr))
+                self.assertEqual(solution, longest_range_with_sorting(in_arr))