Add files via upload

Author: lmizner

Fast_Slow_Pointers/circular_array_loop.py

@@ -0,0 +1,64 @@
+def circular_array_loop(nums):
+    size = len(nums)
+    
+    for i in range(size):
+        slow = fast = i
+        forward = nums[i] > 0
+      
+        while True:
+            slow = next_step(slow, nums[slow], size) 
+            if is_not_cycle(nums, forward, slow):
+                break
+        
+            fast = next_step(fast, nums[fast], size)
+            if is_not_cycle(nums, forward, fast):
+                break
+            
+            fast = next_step(fast, nums[fast], size)
+            if is_not_cycle(nums, forward, fast):
+                break
+        
+            if slow == fast:
+                return True
+                
+    return False
+
+# A function to calculate the next step
+def next_step(pointer, value, size):
+    result = (pointer + value) % size
+    if result < 0:
+        result += size
+    return result
+
+# A function to detect a cycle doesn't exist
+def is_not_cycle(nums, prev_direction, pointer):
+
+        curr_direction = nums[pointer] >= 0
+        if (prev_direction != curr_direction) or (abs(nums[pointer] % len(nums)) == 0):
+            return True
+        else:
+            return False
+
+# Driver code
+def main():
+
+    input = (
+            [-2, -3, -9],
+            [-5, -4, -3, -2, -1],
+            [-1, -2, -3, -4, -5],
+            [2, 1, -1, -2],
+            [-1, -2, -3, -4, -5, 6],
+            [1, 2, -3, 3, 4, 7, 1],
+            [2, 2, 2, 7, 2, -1, 2, -1, -1]
+            )
+    num = 1
+
+    for i in input:
+        print(f"{num}.\tCircular array = {i}")
+        print(f"\n\tFound loop = {circular_array_loop(i)}")
+        print("-"*100, "\n")
+        num += 1
+
+
+if __name__ == "__main__":
+    main()

Fast_Slow_Pointers/duplicate_number_array.py

@@ -0,0 +1,38 @@
+def find_duplicate(nums):
+  fast = slow = nums[0]
+  
+  while True:
+    slow = nums[slow]
+    fast = nums[nums[fast]]
+    if slow == fast:
+      break
+    
+  slow = nums[0]
+   
+  while slow != fast:
+    slow = nums[slow]
+    fast = nums[fast]
+    
+  return fast
+
+
+
+
+
+# Driver code
+def main():
+    nums = [
+        [1, 3, 2, 3, 5, 4], 
+        [2, 4, 5, 4, 1, 3], 
+        [1, 6, 3, 5, 1, 2, 7, 4], 
+        [1, 2, 2, 4, 3], 
+        [3, 1, 3, 5, 6, 4, 2]
+    ]
+    for i in range(len(nums)):
+        print(i + 1, ".\tnums = ", nums[i], sep="")
+        print("\tDuplicate number = ", find_duplicate(nums[i]), sep="")
+        print("-" * 100)
+
+
+if __name__ == '__main__':
+    main()

Fast_Slow_Pointers/happy_numbers.py

@@ -0,0 +1,39 @@
+def is_happy_number(n):
+  
+  # Define function to calculate sum of the squared digits
+  def sum_of_square_digits(num):
+    total_sum = 0
+    for digit in str(num):
+      total_sum += int(digit)**2
+    return total_sum
+    
+  # Initialize slow and fast pointers  
+  slow_pointer = n 
+  fast_pointer = sum_of_square_digits(n)
+  
+  # Continue incrementally moving pointers until we've found a cycle or a happy number
+  while fast_pointer != 1 and slow_pointer != fast_pointer:
+    slow_pointer = sum_of_square_digits(slow_pointer)
+    fast_pointer = sum_of_square_digits(sum_of_square_digits(fast_pointer))
+    
+  # Verify if result is a happy number or not  
+  if fast_pointer == 1:
+    return True
+  
+  return False
+
+
+
+
+def main():
+    inputs = [1, 5, 19, 25, 7]
+    for i in range(len(inputs)):
+        print(i+1, ".\tInput Number: ", inputs[i], sep="")
+        print("\n\tIs it a happy number? ", is_happy_number(inputs[i]))
+        print("-" * 100)
+
+
+if __name__ == '__main__':
+    main()
+
+    

Fast_Slow_Pointers/linked_list_cycle.py

@@ -0,0 +1,145 @@
+class LinkedListNode:
+    # __init__ will be used to make a LinkedListNode type object.
+    def __init__(self, data, next=None):
+        self.data = data
+        self.next = next
+
+
+# Template for the linked list
+class LinkedList:
+    # __init__ will be used to make a LinkedList type object.
+    def __init__(self):
+        self.head = None
+
+    # insert_node_at_head method will insert a LinkedListNode at head
+    # of a linked list.
+    def insert_node_at_head(self, node):
+        if self.head:
+            node.next = self.head
+            self.head = node
+        else:
+            self.head = node
+
+    # create_linked_list method will create the linked list using the
+    # given integer array with the help of InsertAthead method.
+    def create_linked_list(self, lst):
+        for x in reversed(lst):
+            new_node = LinkedListNode(x)
+            self.insert_node_at_head(new_node)
+
+    # returns the number of nodes in the linked list
+    def get_length(self, head):
+        temp = head
+        length = 0
+        while(temp):
+            length+=1
+            temp = temp.next
+        return length
+
+    # returns the node at the specified position(index) of the linked list
+    def get_node(self, head, pos):
+        if pos != -1:
+            p = 0
+            ptr = head
+            while p < pos:
+                ptr = ptr.next
+                p += 1
+            return ptr
+    
+    # __str__(self) method will display the elements of linked list.
+    def __str__(self):
+        result = ""
+        temp = self.head
+        while temp:
+            result += str(temp.data)
+            temp = temp.next
+            if temp:
+                result += ", "
+        result += ""
+        return result
+    
+
+def print_list_with_forward_arrow(linked_list_node):
+    temp = linked_list_node
+    while temp:
+        print(temp.data, end=" ")  # print node value
+        
+        temp = temp.next
+        if temp:
+            print("→", end=" ")
+        else:
+            # if this is the last node, print null at the end
+            print("→ null", end=" ")
+
+def print_list_with_forward_arrow_loop(linked_list_node):
+    temp = linked_list_node
+    while temp:
+        print(temp.data, end=" ")  # print node value
+        
+        temp = temp.next
+        if temp:
+            print("→", end=" ")
+
+
+
+
+
+# DETECT CYCLE 
+def detect_cycle(head):
+  
+  # Initialize slow and fast pointers at the head
+  slow_pointer = head 
+  fast_pointer = head
+  
+  # Continue moving pointers as long as end of list not found
+  while fast_pointer is not None and fast_pointer.next is not None:
+    slow_pointer = slow_pointer.next
+    fast_pointer = fast_pointer.next.next
+    
+    # If cycle is found, return True
+    if slow_pointer == fast_pointer:
+      return True
+  
+  # If end of list found return False
+  return False
+
+
+
+
+
+# Driver code
+def main():
+
+    input = (
+             [2, 4, 6, 8, 10, 12],
+             [1, 3, 5, 7, 9, 11],
+             [0, 1, 2, 3, 4, 6],
+             [3, 4, 7, 9, 11, 17],
+             [5, 1, 4, 9, 2, 3],
+            )
+    pos = [0, -1, 1, -1, 2]
+    j = 1
+
+    for i in range(len(input)):
+
+        input_linked_list = LinkedList()
+        input_linked_list.create_linked_list(input[i])
+        print(f"{j}.\tInput: ", sep="", end="")
+        if pos[i] == -1:
+            print_list_with_forward_arrow(input_linked_list.head)
+        else:
+            print_list_with_forward_arrow_loop(input_linked_list.head)
+        print("\n\tpos:", pos[i])
+        if pos[i] != -1:
+            length = input_linked_list.get_length(input_linked_list.head)
+            last_node = input_linked_list.get_node(input_linked_list.head, length - 1)
+            last_node.next = input_linked_list.get_node(input_linked_list.head, pos[i])
+
+        print(f"\n\tDetected cycle = {detect_cycle(input_linked_list.head)}")
+        j += 1
+        print("-"*100, "\n")
+
+
+if __name__ == "__main__":
+    main()
+