linkedlist solves

Author: Ataba29

Easy/3349.py

@@ -0,0 +1,15 @@
+from typing import List
+
+
+class Solution:
+    def hasIncreasingSubarrays(self, nums: List[int], k: int) -> bool:
+        prev_len = 0
+        start = 0
+        for i in range(1, len(nums) + 1):
+            if i == len(nums) or nums[i] <= nums[i - 1]:
+                length = i - start
+                if prev_len >= k and length >= k or length >= 2 * k:
+                    return True
+                prev_len = length
+                start = i
+        return False

Medium/138.py

@@ -0,0 +1,27 @@
+# Definition for a Node.
+from typing import Optional
+
+
+class Node:
+    def __init__(self, x: int, next: "Node" = None, random: "Node" = None):
+        self.val = int(x)
+        self.next = next
+        self.random = random
+
+
+class Solution:
+    def copyRandomList(self, head: "Optional[Node]") -> "Optional[Node]":
+        or_to_new = {None: None}
+        curr = head
+        while curr:
+            copy = Node(curr.val)
+            or_to_new[curr] = copy
+            curr = curr.next
+
+        curr = head
+        while curr:
+            copy = or_to_new[curr]
+            copy.next = or_to_new[curr.next]
+            copy.random = or_to_new[curr.random]
+            curr = curr.next
+        return or_to_new[head]

Medium/19.py

@@ -2,27 +2,23 @@
 from typing import Optional
 
 
-class Node:
-    def __init__(self, x: int, next: "Node" = None, random: "Node" = None):
-        self.val = int(x)
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
         self.next = next
-        self.random = random
 
 
 class Solution:
-    def copyRandomList(self, head: "Optional[Node]") -> "Optional[Node]":
-        mapp = {None: None}
-        curr = head
-        while curr:
-            copy = Node(curr.val)
-            mapp[curr] = copy
-            curr = curr.next
+    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
+        res = ListNode(0, head)
+        dummy = res
 
-        curr = head
-        while curr:
-            copy = mapp[curr]
-            copy.next = mapp[curr.next]
-            copy.random = mapp[curr.random]
-            curr = curr.next
+        for _ in range(n):
+            head = head.next
 
-        return mapp[head]
+        while head:
+            head = head.next
+            dummy = dummy.next
+
+        dummy.next = dummy.next.next
+        return res.next

Medium/61.py

@@ -0,0 +1,34 @@
+# Definition for singly-linked list.
+from typing import Optional
+
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+
+class Solution:
+    def rotateRight(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
+        if not head or not head.next or k == 0:
+            return head
+
+        # find length and tail
+        length = 1
+        tail = head
+        while tail.next:
+            tail = tail.next
+            length += 1
+
+        k = k % length
+        if k == 0:
+            return head
+
+        curr = head
+        for _ in range(length - k - 1):
+            curr = curr.next
+
+        new_head = curr.next
+        curr.next = None
+        tail.next = head
+        return new_head

Medium/82.py

@@ -0,0 +1,26 @@
+# Definition for singly-linked list.
+from typing import Optional
+
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+
+class Solution:
+    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        res = ListNode(-1, head)
+        dummy = res
+        prev = res
+        cur = head
+        while cur and cur.next:
+            if cur.val == cur.next.val:
+                while cur.next and cur.val == cur.next.val:
+                    cur = cur.next
+                prev.next = cur.next
+            else:
+                prev = prev.next
+            cur = cur.next
+
+        return res.next

Medium/92.py

@@ -0,0 +1,31 @@
+from typing import Optional
+
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+
+class Solution:
+    def reverseBetween(
+        self, head: Optional[ListNode], left: int, right: int
+    ) -> Optional[ListNode]:
+
+        if not head or left == right:
+            return head
+
+        dummy = ListNode(0, head)
+        prev = dummy
+
+        for _ in range(left - 1):
+            prev = prev.next
+
+        cur = prev.next
+        for _ in range(right - left):
+            temp = cur.next
+            cur.next = temp.next
+            temp.next = prev.next
+            prev.next = temp
+
+        return dummy.next

README.md

@@ -17,11 +17,11 @@ This repository contains my solutions to various LeetCode problems. Each solutio
 
 ### Easy Problems
 
-- **Total Solved:** [46]
+- **Total Solved:** [47]
 
 ### Medium Problems
 
-- **Total Solved:** [118]
+- **Total Solved:** [121]
 
 ### Hard Problems