Added committed

Author: abhijitmjj

data_structures/arrays/max_consecutive_ones.py

@@ -0,0 +1,41 @@
+from typing import List
+
+"""
+Given a binary array nums and an integer k, return the maximum number of consecutive 1's in the array if you can flip at most k 0's.
+Example 1:
+
+Input: nums = [1,1,1,0,0,0,1,1,1,1,0], k = 2
+Output: 6
+Explanation: [1,1,1,0,0,1,1,1,1,1,1]
+Bolded numbers were flipped from 0 to 1. The longest subarray is underlined.
+Example 2:
+
+Input: nums = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], k = 3
+Output: 10
+Explanation: [0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]
+Bolded numbers were flipped from 0 to 1. The longest subarray is underlined.
+ 
+
+Constraints:
+
+1 <= nums.length <= 105
+nums[i] is either 0 or 1.
+0 <= k <= nums.length
+"""
+
+class Solution:
+    def longestOnes(self, nums: List[int], k: int) -> int:
+        left = 0
+        current_count = 0
+        max_count = 0
+        for right in range(len(nums)):
+            if nums[right] == 0:
+                current_count += 1
+            
+            while current_count > k:
+                if nums[left] == 0:
+                    current_count -= 1
+                left += 1
+        
+            max_count = max(max_count, right - left + 1)
+        return max_count

data_structures/arrays/min_sub_array_len.py

@@ -0,0 +1,68 @@
+"""Sliding Window Technique
+The sliding window technique involves maintaining a window that can expand and contract as needed to meet the conditions of the problem. Here's the step-by-step approach:
+
+Initialize Variables:
+
+left pointer starting at the beginning of the array.
+current_sum to keep track of the sum of the current window.
+min_length to store the minimum length of the valid subarray found.
+Expand and Contract the Window:
+
+Expand the window by moving the right pointer and adding the element at the right pointer to current_sum.
+Once current_sum is greater than or equal to target, contract the window from the left side to see if we can get a smaller valid window.
+Update min_length whenever a valid window is found.
+Return the Result:
+
+If min_length is not updated, return 0 indicating no valid subarray was found.
+Otherwise, return min_length."""
+
+def min_sub_array_len(target: int, nums: list[int]):
+    n = len(nums)
+    left = 0
+    current_sum = 0
+    min_length = float('inf')
+    
+    for right in range(n):
+        current_sum += nums[right]
+        
+        while current_sum >= target:
+            min_length = min(min_length, right - left + 1)
+            current_sum -= nums[left]
+            left += 1
+    
+    return 0 if min_length == float('inf') else min_length
+
+# Example usage
+target = 7
+nums = [2, 3, 1, 2, 4, 3]
+print(min_sub_array_len(target, nums))  # Output: 2
+
+target = 4
+nums = [1, 4, 4]
+print(min_sub_array_len(target, nums))  # Output: 1
+
+target = 11
+nums = [1, 1, 1, 1, 1, 1, 1, 1]
+print(min_sub_array_len(target, nums))  # Output: 0
+
+"""
+Explanation of the Code
+Initialization:
+
+left is initialized to 0.
+current_sum starts at 0.
+min_length is set to infinity to ensure any valid subarray length found will be smaller.
+Main Loop:
+
+The right pointer iterates over the array.
+current_sum is updated to include nums[right].
+Inner While Loop:
+
+Checks if current_sum is greater than or equal to target.
+If true, it updates min_length and contracts the window from the left by incrementing left and subtracting nums[left] from current_sum.
+Return Result:
+
+If min_length remains infinity, it means no valid subarray was found, so return 0.
+Otherwise, return min_length.
+Time Complexity:
+The time complexity is O(n) since both the left and right pointers traverse the array at most once."""

data_structures/linked_list/singly_linked_list_with_tail.py

@@ -0,0 +1,125 @@
+from typing import Any
+
+class Node:
+    def __init__(self, data: Any):
+        self.data = data
+        self.next : Node  | None = None
+
+
+class SinglyLinkedList:
+    def __init__(self):
+        self.head: Node | None = None
+        self.tail: Node | None = None
+
+    def append(self, data: Any):
+        """Append a node with the given data to the end of the list."""
+        new_node = Node(data)
+        if not self.head:
+            self.head = new_node
+            self.tail = new_node
+        else:
+            self.tail.next = new_node
+            self.tail = new_node
+
+    def prepend(self, data):
+        """Prepend a node with the given data to the start of the list."""
+        new_node = Node(data)
+        if not self.head:
+            self.head = new_node
+            self.tail = new_node
+        else:
+            new_node.next = self.head
+            self.head = new_node
+
+    def delete_node(self, key):
+        """Delete the first node with the given data."""
+        current = self.head
+        if current and current.data == key:
+            self.head = current.next
+            if self.head is None:  # List becomes empty
+                self.tail = None
+            current = None
+            return
+
+        prev = None
+        while current and current.data != key:
+            prev = current
+            current = current.next
+
+        if current is None:
+            return
+
+        prev.next = current.next
+        if current.next is None:  # Deleted node was the tail
+            self.tail = prev
+        current = None
+
+    def search(self, key):
+        """Search for a node with the given data."""
+        current = self.head
+        while current and current.data != key:
+            current = current.next
+        return current
+
+    def print_list(self):
+        """Print the entire list."""
+        current = self.head
+        while current:
+            print(current.data, end=" -> ")
+            current = current.next
+        print("None")
+
+    def insert_after_node(self, prev_node, data):
+        """Insert a node with the given data after a specified node."""
+        if not prev_node:
+            print("Previous node does not exist.")
+            return
+        new_node = Node(data)
+        new_node.next = prev_node.next
+        prev_node.next = new_node
+        if new_node.next is None:  # New node becomes the tail
+            self.tail = new_node
+
+    def length(self):
+        """Return the length of the linked list."""
+        count = 0
+        current = self.head
+        while current:
+            count += 1
+            current = current.next
+        return count
+
+    def reverse(self):
+        """Reverse the linked list."""
+        prev = None
+        current = self.head
+        self.tail = self.head  # Update the tail to be the old head
+        while current:
+            next_node = current.next
+            current.next = prev
+            prev = current
+            current = next_node
+        self.head = prev
+
+# Example usage
+if __name__ == "__main__":
+    linked_list = SinglyLinkedList()
+    linked_list.append(1)
+    linked_list.append(2)
+    linked_list.append(3)
+    linked_list.prepend(0)
+    linked_list.print_list()  # Output: 0 -> 1 -> 2 -> 3 -> None
+
+    linked_list.delete_node(2)
+    linked_list.print_list()  # Output: 0 -> 1 -> 3 -> None
+
+    print("Length:", linked_list.length())  # Output: Length: 3
+
+    linked_list.reverse()
+    linked_list.print_list()  # Output: 3 -> 1 -> 0 -> None
+
+    found_node = linked_list.search(1)
+    print("Found:", found_node.data if found_node else "Not Found")  # Output: Found: 1
+
+    linked_list.insert_after_node(found_node, 2)
+    linked_list.print_list()  # Output: 3 -> 1 -> 2 -> 0 -> None