add linked list and simple summaryranges

Author: GishB

InterviewAlgorithms/SummaryRanges.py

@@ -0,0 +1,56 @@
+# You are given a sorted unique integer array nums.
+#
+# A range [a,b] is the set of all integers from a to b (inclusive).
+#
+# Return the smallest sorted list of ranges that cover all the numbers in the array exactly. That is, each element of nums is covered by exactly one of the ranges, and there is no integer x such that x is in one of the ranges but not in nums.
+#
+# Each range [a,b] in the list should be output as:
+# "a->b" if a != b
+# "a" if a == b
+
+# Example 1:
+#
+# Input: nums = [0,1,2,4,5,7]
+# Output: ["0->2","4->5","7"]
+# Explanation: The ranges are:
+# [0,2] --> "0->2"
+# [4,5] --> "4->5"
+# [7,7] --> "7"
+#
+# Example 2:
+#
+# Input: nums = [0,2,3,4,6,8,9]
+# Output: ["0","2->4","6","8->9"]
+# Explanation: The ranges are:
+# [0,0] --> "0"
+# [2,4] --> "2->4"
+# [6,6] --> "6"
+# [8,9] --> "8->9"
+#
+
+from typing import List
+
+def summaryRanges(nums: List[int]) -> List[str]:
+    if nums:
+        dp = []
+        length_num = len(nums)
+        a_val = nums[0]
+        for index, current_val in enumerate(nums):
+            if index > length_num - 1:
+                break
+            else:
+                next_val = nums[index+1] if index != length_num -1 else nums[index]
+                b_val = current_val
+                if current_val + 1 != next_val:
+                    if a_val != b_val:
+                        dp.append(f"{a_val}->{b_val}")
+                    else:
+                        dp.append(f"{a_val}")
+                    a_val = next_val
+        return dp
+    else:
+        return nums
+
+if __name__ == "__main__":
+    print(summaryRanges(nums=[1,2,3,5,6,9]))
+

KarpovCoursesAlgorithms/InOrderSmallestBinTree.py

@@ -0,0 +1,51 @@
+
+# Задача: K-ый наименьший элемент
+
+# Описание:
+# Вам дан корень head бинарного дерева поиска (BST) и число k.
+# Необходимо найти k-ый (нумерация с единицы) наименьший элемент в этом дереве поиска.
+
+# Каждый узел дерева задается экземпляром класса Node, определенным ниже:
+
+# Example №1: head = [3,1,4,null,2], k = 1. Ответ: 1
+# Example №2: head = [5,3,6,2,4,null,null,1], k = 3. Ответ: 3
+
+from typing import List, Optional
+
+class Node:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+def inorder(head: Node) -> List[int]:
+    stack = []
+    ans = []
+    curr = head
+    while curr is not None or len(stack) > 0:
+        while curr is not None:
+            stack.append(curr)
+            curr = curr.left
+
+        curr = stack.pop()
+        ans.append(curr.val)
+
+        curr = curr.right
+    return ans
+
+
+
+def kth_smallest(head: Optional[Node], k: int) -> Optional[int]:
+    if head is not None:
+        return inorder(head=head)[k-1]
+    else:
+        return head
+
+
+# if __name__ == "__main__":
+#     example = Node(val= 5,
+#                    left=Node(val=3, right=Node(val=4),
+#                        left=Node(val=2,
+#                                  left=Node(val=1))),
+#                    right=Node(val=6))
+#     print(kth_smallest(head=example, k=1))

KarpovCoursesAlgorithms/RotateLinkedList.py

@@ -0,0 +1,54 @@
+# Task name: Поворот односвязного списка
+# Desc general: Вам дана голова односвязного списка head.
+# Вам необходимо «повернуть» его направо на k позиций.
+
+
+# Example: 1 - 2 - 3 - 4 - 5
+# Example solution: 4 - 5 - 1 - 2 - 3
+
+# Task description:
+# Напишите функцию rotate_right(head, k),
+# которая будет возвращать голову повернутого листа.
+# Вам нельзя создавать новый односвязный список — нужно все изменения делать с существующим
+# (т.е. переставлять связи внутри него).
+
+# Считайте, что односвязный список задан классом Node
+# (при этом head есть экземпляр данного класса), код которого дан ниже.
+
+from typing import Optional, Tuple
+
+
+# class Node:
+#     def __init__(self, value, next=None):
+#         self.value = value
+#         self.next = next
+
+def rotate_right(head, k):
+    if not head or k <= 0:
+        return head
+
+    # Step 1: Find the length of the linked list
+    length = 1
+    tail = head
+    while tail.next:
+        length += 1
+        tail = tail.next
+
+    # Step 2: Find the new tail (node before the new head)
+    new_tail = head
+    for _ in range(length - k - 1):
+        new_tail = new_tail.next
+
+    # Step 3: Detach and move the last k nodes to front
+    new_head = new_tail.next
+    new_tail.next = None
+    tail.next = head
+
+    return new_head
+
+
+# if __name__ == "__main__":
+#     example = Node(1, Node(2, Node(3, Node(4, Node(5)))))
+#     solution = Node(5, Node(4, Node(1, Node(2, Node(3)))))
+#     tmp = rotate_right(example, 1)
+#     print("stop")