Add files via upload

Author: lmizner

Two_Pointers/3sum.py

@@ -0,0 +1,49 @@
+def find_sum_of_three(nums, target):
+  # Sort the array in ascending order
+  nums.sort()
+  
+  # for loop will cycle through each index of nums for i 
+  for i in range(0, len(nums)-2):
+    # Pointers start positions must be defined inside for loop, so the reset at each loop
+    pointer_1 = i + 1
+    pointer_2 = len(nums) - 1
+    # Ensure that each combo of values is tried without overlap of pointers
+    while pointer_1 < pointer_2:
+      # Calculate sum
+      sum = nums[i] + nums[pointer_1] + nums[pointer_2]
+      # If a match is found, return True
+      if sum == target:
+        return True
+      # If we're less than target, increase pointer_1 value
+      elif sum < target:
+        pointer_1 += 1 
+      # If we're greater than target, decrease pointer_2 value
+      elif sum > target:
+        pointer_2 -= 1
+    # Iterate through i
+    i += 1 
+  # If no match found, return False
+  return False
+
+
+
+# Driver code
+def main():
+    nums_lists = [[3, 7, 1, 2, 8, 4, 5],
+                  [-1, 2, 1, -4, 5, -3],
+                  [2, 3, 4, 1, 7, 9],
+                  [1, -1, 0],
+                  [2, 4, 2, 7, 6, 3, 1]]
+
+    targets = [10, 7, 20, -1, 8]
+
+    for i in range(len(nums_lists)):
+        print(i + 1, ".\tInput array: ", nums_lists[i], sep="")
+        if find_sum_of_three(nums_lists[i], targets[i]):
+            print("\tSum for", targets[i], "exists")
+        else:
+            print("\tSum for", targets[i], "does not exist")
+        print("-"*100)
+
+if __name__ == '__main__':
+    main()

Two_Pointers/linked_list_remove_nth_node.py

@@ -0,0 +1,84 @@
+# Template for linked list node class
+class LinkedListNode:
+    def __init__(self, data, next=None):
+        self.data = data
+        self.next = next
+
+# Template for the linked list
+class LinkedList:
+    def __init__(self):
+        self.head = None
+
+    # Method to insert a node at the head of the linked list
+    def insert_node_at_head(self, node):
+        if self.head:
+            node.next = self.head
+        self.head = node
+
+    # Method to create a linked list from a list of values
+    def create_linked_list(self, values):
+        for value in reversed(values):
+            self.insert_node_at_head(LinkedListNode(value))
+
+
+
+
+
+def remove_nth_last_node(head, n):
+    right = head
+    left = head
+    
+    # Move the right pointer forward n steps
+    for i in range(n):
+        right = right.next
+    
+    # If right is None after moving n steps, we need to remove the head (i.e. n exceeds length of linked list)
+    if right is None:
+        return head.next  # Removing the head
+    
+    # Move both pointers forward until right reaches the end
+    while right.next is not None:
+        right = right.next
+        left = left.next
+    
+    # Remove the Nth node from the end
+    left.next = left.next.next
+
+    return head
+
+
+
+
+
+# Function to print the linked list
+def print_list_with_forward_arrow(head):
+    current = head
+    while current:
+        print(current.data, end=" -> " if current.next else "")
+        current = current.next
+    print()
+
+# Driver code
+def main():
+    lists = [
+        [23, 89, 10, 5, 67, 39, 70, 28],
+        [34, 53, 6, 95, 38, 28, 17, 63, 16, 76],
+        [288, 224, 275, 390, 4, 383, 330, 60, 193],
+        [1, 2, 3, 4, 5, 6, 7, 8, 9],
+        [69, 8, 49, 106, 116, 112, 104, 129, 39, 14, 27, 12]
+    ]
+    n = [4, 1, 6, 9, 11]
+
+    for i in range(len(n)):
+        input_linked_list = LinkedList()
+        input_linked_list.create_linked_list(lists[i])
+        print(i + 1, ". Linked List:\t", end='')
+        print_list_with_forward_arrow(input_linked_list.head)
+        print("n = ", n[i])
+        result = remove_nth_last_node(input_linked_list.head, n[i])
+        print("Updated Linked List:\t", end='')
+        print_list_with_forward_arrow(result)
+        print("-" * 100)
+
+if __name__ == '__main__':
+    main()

Two_Pointers/reverse_words_string.py

@@ -0,0 +1,41 @@
+def reverse_words(sentence):
+  # Remove any leading or trailing spaces from the sentence
+  sentence = sentence.strip()
+  
+  # Split the string into words
+  words = sentence.split()
+  
+  # Reverse order of words using two pointers
+  start = 0
+  end = len(words) - 1
+  
+  while start < end:
+    words[start], words[end] = words[end], words[start]
+    start += 1
+    end -= 1
+  
+  # Join words back into sentence
+  return ' '.join(words)
+
+
+
+
+# Driver code
+def main():
+    string_to_reverse = ["Hello World",
+                        "a   string   with   multiple   spaces",
+                        "Case Sensitive Test Case 1234",
+                        "a 1 b 2 c 3 d 4 e 5",
+                        "     trailing spaces",
+                        "case test interesting an is this"]
+
+    for i in range(len(string_to_reverse)):
+        print(i + 1, ".\tOriginal string: '" + "".join(string_to_reverse[i]), "'", sep='')
+        result = reverse_words(string_to_reverse[i])
+
+        print("\tReversed string: '" + "".join(result), "'", sep='')
+        print("-" * 100)
+
+
+if __name__ == '__main__':
+    main()

Two_Pointers/sort_colors.py

@@ -0,0 +1,41 @@
+def sort_colors(colors):
+  
+  # Initialize starting indices of pointers
+  start = 0
+  current = 0
+  end = len(colors) - 1
+  
+  # End loop when current index becomes greater than end index
+  while current <= end:
+    # Swap start and current values
+    if colors[current] == 0:
+      colors[start], colors[current] = colors[current], colors[start]
+      start += 1
+      current += 1
+    # No swap of values, continue to next iteration in the loop
+    elif colors[current] == 1:
+      current += 1
+    # Swap end and current values
+    else:
+      colors[end], colors[current] = colors[current], colors[end]
+      end -= 1
+
+  return colors
+
+
+
+
+# Driver code
+def main():
+    inputs = [[0, 1, 0], [1, 1, 0, 2], [2, 1, 1, 0, 0], [2, 2, 2, 0, 1, 0], [2, 1, 1, 0, 1, 0, 2]]
+
+    # Iterate over the inputs and print the sorted array for each
+    for i in range(len(inputs)):
+        colors=inputs[i]
+        print(i + 1, ".\tcolors:", colors)
+        sort_colors(colors)
+        print("\n\tThe sorted array is:", colors)
+        print("-" * 100)
+
+if __name__ == "__main__":
+    main()

Two_Pointers/valid_palindrome.py

@@ -0,0 +1,30 @@
+def is_palindrome(s):
+  # Initialize pointer 1 at the start of the string and pointer 2 at end of the string
+  pointer_1 = 0
+  pointer_2 = len(s) - 1
+  
+  # Continue to loop until the pointers meet at the midpoint
+  while pointer_1 <= pointer_2:
+    # If there's a match, move pointers inward
+    if s[pointer_1] == s[pointer_2]:
+      pointer_1 += 1 
+      pointer_2 -= 1
+    else:
+      # If there's no match
+      return False
+  # If we make it to the midpoint and all match return True
+  return True
+
+
+# Driver code
+def main():
+    test_cases = ["RACECAR", "ABBA", "TART"]
+    i = 1
+    for s in test_cases:
+        print("Test Case #", i)
+        print(is_palindrome(s))
+        print("-" * 100, end="\n\n")
+        i = i + 1
+
+if __name__ == '__main__':
+    main()

Two_Pointers/valid_palindrome_II.py

@@ -0,0 +1,51 @@
+def is_palindrome(string):
+    
+    # Initialize one pointer at the start and one at the end
+    start = 0
+    end = len(string) - 1
+    
+    while start < end:
+        if string[start] == string[end]:
+            start += 1
+            end -= 1
+        else:
+            # If there's a mismatch, check two cases:
+            # 1. Skip the start character
+            # 2. Skip the end character
+            skip_start = check_palindrome(string, start + 1, end)
+            skip_end = check_palindrome(string, start, end - 1)
+            return skip_start or skip_end
+    
+    return True
+
+def check_palindrome(string, left, right):
+    while left < right:
+        if string[left] != string[right]:
+            return False
+        left += 1
+        right -= 1
+    return True
+
+
+
+# Driver code
+def main():
+    test_cases = [
+        "madame", 
+        "dead", 
+        "abca", 
+        "tebbem", 
+        "eeccccbebaeeabebccceea"
+    ]
+    
+    i = 1
+    for s in test_cases:
+        print("Test Case #", i)
+        print(f"Input: '{s}'")
+        result = is_palindrome(s)
+        print("Is valid palindrome after at most one removal?:", result)
+        print("-" * 100, end="\n\n")
+        i += 1
+
+if __name__ == '__main__':
+    main()

Two_Pointers/valid_word_abbreviation.py

@@ -0,0 +1,67 @@
+def valid_word_abbreviation(word, abbr):
+
+  # Initialize pointer start locations
+  word_pointer = 0
+  abbr_pointer = 0
+  
+  # Continue loop until end of abbr in reached
+  while abbr_pointer < len(abbr):
+    
+    # Check if alphabetical character
+    if abbr[abbr_pointer].isalpha():
+     
+      # Verify that alphabetical characters match between word and abbr
+      if word_pointer < len(word) and word[word_pointer] == abbr[abbr_pointer]:  
+        word_pointer += 1
+      
+      else:
+        return False
+        
+      abbr_pointer += 1
+    
+    # Check if numerical character
+    elif abbr[abbr_pointer].isdigit():
+      
+      # Check for leading zero
+      if abbr[abbr_pointer] == '0':
+        return False
+        
+      # Capture entire numerical value
+      start = abbr_pointer
+    
+      while abbr_pointer < len(abbr) and abbr[abbr_pointer].isdigit():
+        abbr_pointer += 1
+      
+      # Convert numerical substring to an integer
+      num = int(abbr[start:abbr_pointer])
+      word_pointer += num
+      
+      # Check that we didn't exceed length of word
+      if word_pointer > len(word):
+        return False
+        
+    # If neither alphabetical or numerical scenario is satisfied
+    else:
+      return False
+
+  # Check that we reached the end of the word
+  if word_pointer != len(word):
+    return False
+  
+  return True
+  
+
+
+
+def main():
+    words = ["a", "a", "abcdefghijklmnopqrst", "abcdefghijklmnopqrst", "word", "internationalization", "localization"]
+    abbreviations = ["a", "b", "a18t", "a19t", "w0rd", "i18n", "l12n"]
+
+    for i in range(len(words)):
+        print(i + 1, ".\t word: '", words[i], "'", sep="")
+        print("\t abbr: ", abbreviations[i], "'", sep="")
+        print(f"\n\t Is '{abbreviations[i]}' a valid abbreviation for the word '{words[i]}'? ", valid_word_abbreviation(words[i], abbreviations[i]), sep="")
+        print("-" * 100)
+
+if __name__ == '__main__':
+    main()