@@ -0,0 +1,13 @@
+class Solution:
+def hasCycle(self, head):
+slow = head
+fast = head
+
+while fast and fast.next:
+slow = slow.next
+fast = fast.next.next
+
+if slow == fast:
+return True
+
+return False

@@ -0,0 +1,33 @@
+class Solution:
+def detectCycle(self, head):
+slow = head
+fast = head
+
+while fast and fast.next:
+slow = slow.next
+fast = fast.next.next
+
+if slow == fast:
+break
+
+if not fast or not fast.next:
+return None
+
+slow = head
+while slow != fast:
+slow = slow.next
+fast = fast.next
+
+return slow
+
+
+class Solution2:
+def detectCycle(self, head):
+cur = head
+seen = set()
+
+while cur:
+if cur in seen:
+return cur
+seen.add(cur)
+cur = cur.next

@@ -0,0 +1,38 @@
+class Solution:
+def isHappy(self, n: int) -> bool:
+slow = n
+fast = n
+
+while True:
+slow = self.findSquare(slow)
+fast = self.findSquare(self.findSquare(fast))
+if slow == fast:
+break
+
+return slow == 1
+
+def findSquare(self, n):
+square = 0
+while n != 0:
+square += (n % 10) ** 2
+n = n // 10
+return square
+
+class Solution2:
+def isHappy(self, n: int) -> bool:
+seen = set()
+
+while n not in seen:
+seen.add(n)
+n = self.find_square(n)
+
+return n == 1
+
+def find_square(self, num: int) -> int:
+square = 0
+
+while num != 0:
+square += (num % 10) ** 2
+num = num // 10
+
+return square

@@ -0,0 +1,10 @@
+class Solution:
+def middleNode(self, head):
+slow = head
+fast = head
+
+while fast and fast.next:
+slow = slow.next
+fast = fast.next.next
+
+return slow

@@ -0,0 +1,21 @@
+class Solution:
+def merge(self, intervals):
+if len(intervals) <= 1: return intervals
+
+intervals.sort(key=lambda interval: interval[0])
+mergedIntervals = []
+start = intervals[0][0]
+end = intervals[0][1]
+
+for i in range(1, len(intervals)):
+interval = intervals[i]
+
+if interval[0] <= end:
+end = max(end, interval[1])
+else:
+mergedIntervals.append([start, end])
+start = interval[0]
+end = interval[1]
+
+mergedIntervals.append([start, end])
+return mergedIntervals

@@ -0,0 +1,41 @@
+class Solution:
+def insert(self, intervals, newInterval):
+res = []
+i = 0
+
+while i < len(intervals) and intervals[i][1] < newInterval[0]:
+res.append(intervals[i])
+i += 1
+
+while i < len(intervals) and intervals[i][0] <= newInterval[1]:
+newInterval[0] = min(newInterval[0], intervals[i][0])
+newInterval[1] = max(newInterval[1], intervals[i][1])
+i += 1
+
+res.append(newInterval)
+
+while i < len(intervals):
+res.append(intervals[i])
+i += 1
+
+return res
+
+class Solution2:
+def insert(self, intervals, newInterval):
+if not intervals: return [newInterval]
+
+left = []
+right = []
+new_start = newInterval[0]
+new_end = newInterval[1]
+
+for start, end in intervals:
+if end < new_start:
+left.append([start, end])
+elif start > new_end:
+right.append([start, end])
+else:
+new_start = min(new_start, start)
+new_end = max(new_end, end)
+
+return left + [[new_start, new_end]] + right

@@ -0,0 +1,11 @@
+class Solution:
+def canAttendMeetings(self, intervals):
+if len(intervals) < 2: return True
+
+intervals.sort(key=lambda interval: interval[0])
+
+for i in range(1, len(intervals)):
+if intervals[i][0] < intervals[i-1][1]:
+return False
+
+return True