adde leetcode code

Author: developer-Akhil

Linked_List/__init__.py

@@ -0,0 +1,63 @@
+""" write a function that determines if a singly linked list is circular and if it is, we are going to return the node where the cycle begins.
+This solution is based off of Robert Floyd’s algorithm, first discovered in the 1970’s. """
+
+""" Floyd’s cycle finding algorithm or Hare-Tortoise algorithm is a pointer algorithm that uses only two pointers, moving through the sequence
+at different speeds. This algorithm is used to find a loop in a linked list. It uses two pointers one moving twice as fast as the other one.
+The faster one is called the faster pointer and the other one is called the slow pointer. """
+
+""" How Does Floyd’s Cycle Finding Algorithm Works? """
+
+""" While traversing the linked list one of these things will occur """
+
+""" 
+1)  The Fast pointer may reach the end (NULL) this shows that there is no loop n the linked list.
+2) The Fast pointer again catches the slow pointer at some time therefore a loop exists in the linked list.
+"""
+
+from typing import Optional
+
+
+class ListNode:
+    def __init__(self, data=None, next=None):
+        self.data = data
+        self.next = next
+        # self.next = None
+
+
+class Solution:
+
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+
+        slow, fast = head, head
+
+        while fast and fast.next:
+
+            slow = head.next
+            fast = head.next.next
+            print("klasjld")
+            if slow == fast:
+                print("kfdjsl")
+                return True
+        return False
+
+
+firstNode = ListNode(1)
+linkedList = Solution()
+
+head = None
+for i in reversed(range(5)):
+    head = ListNode(i + 1, head)
+
+# insert cycle
+# head.next.next.next.next.next = head.next.next
+
+if Solution().hasCycle(head):
+    print('Cycle Found')
+else:
+    print('No Cycle Found')
+
+# listNode=ListNode(1)
+# listNode.val=2
+# listNode.val=3
+# listNode.val=4
+# listNode.val=5

Linked_List/lc_141.py

@@ -0,0 +1,70 @@
+# vedio : https://www.youtube.com/watch?v=RhCGA4jlPmQ&list=PLzjoZGHG3J8vdUH75YPqmO7lbQl_M-xXo&index=2
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.next = None
+
+
+class LinkedList:
+    def __init__(self):
+        self.head = None
+
+    def insert(self, newNode):
+        if self.head is None:
+            self.head = newNode
+
+        else:
+            lastNode = self.head
+
+            while True:
+                if lastNode.next is None:
+                    break
+                lastNode = lastNode.next
+            lastNode.next = newNode
+
+    def printList(self):
+
+        currentNode = self.head
+        while True:
+            if currentNode is None:
+                break
+            print(currentNode.data, end=' ')
+            currentNode = currentNode.next
+
+    def reverseList(self, head) -> Node:
+
+        prev = None
+
+        while head:
+            temp = head
+            head = head.next
+            temp.next = prev
+            prev = temp
+
+        return prev
+
+
+from typing import Optional
+
+# class Solution:
+
+
+firstNode = Node(1)
+linkedList = LinkedList()
+linkedList.insert(firstNode)
+secondNode = Node(2)
+linkedList.insert(secondNode)
+thirdNode = Node(3)
+linkedList.insert(thirdNode)
+fourthNode = Node(4)
+linkedList.insert(fourthNode)
+fifthNode = Node(5)
+linkedList.insert(fifthNode)
+linkedList.printList()
+
+rev = linkedList.reverseList(firstNode)
+
+print("\n")
+while rev:
+    print(rev.data, end=' ')
+    rev = rev.next

Linked_List/lc_206.py

@@ -0,0 +1,71 @@
+class Node:
+
+    def __init__(self, data):
+        self.data = data
+        self.next = None
+
+
+class LinkedList:
+
+    def __init__(self):
+        self.start = None
+
+    def deleteFirst(self):
+        if self.start is None:
+            print("Linked list is empty")
+        else:
+            temp = self.start
+            self.start = self.start.next
+
+    def insertLast(self, value):
+        newNode = Node(value)
+        if self.start is None:
+            self.start = newNode
+        else:
+            temp = self.start
+            while temp.next is not None:
+                temp = temp.next
+            temp.next = newNode
+
+    def viewList(self):
+
+        if self.start is None:
+            print("List is empty")
+        else:
+            temp = self.start
+            while temp is not None:
+                print(temp.data, end=' ')
+                temp = temp.next
+
+    def reverseList(self):
+
+        prev = None
+
+        while self.start:
+
+            temp = self.start
+            self.start = self.start.next
+            temp.next = prev
+            prev = temp
+        return prev
+
+
+mylist = LinkedList()
+mylist.insertLast(10)
+mylist.insertLast(20)
+mylist.insertLast(30)
+mylist.insertLast(40)
+mylist.viewList()
+print("\n")
+reversList = mylist.reverseList()
+
+# print(reversList.data)
+
+while reversList:
+    print(reversList.data,end=" ")
+    reversList = reversList.next
+
+# mylist.deleteFirst()
+
+# mylist.viewList()
+# input()

Linked_List/ll_implementation.py

@@ -0,0 +1,69 @@
+
+from typing import List
+
+# class Solution():
+#
+#     def setZeroes(self,matrix:List[List[int]]):
+#
+#         ROWS,COLS = len(matrix),len(matrix[0])
+#         rowZero = False
+#
+#         for r in range(ROWS):
+#             for c in range(COLS):
+#                 if matrix[r][c] == 0:
+#                     matrix[0][c] = 0
+#
+#                     if r > 0:
+#                         matrix[r][0] = 0
+#                     else:
+#                         rowZero = True
+#
+#         for i in range(1,ROWS):
+#             for c in range(1,COLS):
+#                 if matrix[0][r] == 0 or matrix[r][0] == 0:
+#                     matrix[r][c]
+#         if matrix[0][0] == 0:
+#
+#             for r in range(ROWS):
+#                 matrix[r][0]=0
+#
+#         if rowZero:
+#             for c in range(COLS):
+#                 matrix[0][c]=0
+
+class Solution:
+
+    def setZeroes(self, matrix: List[List[int]]): #-> None:
+        """
+            Do not return anything, modify matrix in-place instead.
+        """
+        rLen,cLen=len(matrix),len(matrix[0])
+
+        col=[1]*cLen
+
+        for r in range(rLen):
+            flag = 0  # flag=1 INDICATES CURRENT ROW CONTAINS 0
+            for c in range(cLen):
+
+                if matrix[r][c] == 0:
+                    flag = 1
+                    col[c] = 0
+
+            if flag:  # flag=1 INDICATES CURRENT ROW CONTAINS 0, SET ENTIRE ROW TO 0
+                matrix[r] = [0] * cLen
+
+        '''
+            col INDICATES WHICH COLUMN HAS 0,
+            BELOW LOOP SET THE CORRESPONDING COLUMN 0
+
+        '''
+        for r in range(rLen):
+            for c in range(cLen):
+                if col[c] == 0:
+                    matrix[r][c] = 0
+
+        return matrix
+
+matrix = [[1,1,1],[1,0,1],[1,1,1]]
+
+print(Solution().setZeroes(matrix))

Matrix/__init__.py

@@ -0,0 +1,35 @@
+'''
+Minimum rotations required to get the same string
+Difficulty Level : Medium
+Last Updated : 28 Dec, 2021
+Given a string, we need to find the minimum number of rotations required to get the same string.
+Examples:
+
+
+Input : s = "geeks"
+Output : 5
+
+Input : s = "aaaa"
+Output : 1
+'''
+
+def findRotations(string):
+
+    tmp = string + string
+
+    n = len(string)
+
+    for i in range (1,n+1):
+
+        #substring from i index of original string size
+        substring = tmp[i:i+n]
+
+        # if substring matches with original string then we will come out of the loop
+
+        if substring == string:
+            return i
+
+    return n
+
+string="abc"
+print(findRotations(string))

Matrix/caa_mtr_73.py

@@ -0,0 +1,38 @@
+'''
+Generate all rotations of a given string
+Difficulty Level : Easy
+Last Updated : 02 Nov, 2021
+Given a string S. The task is to print all the possible rotated strings of the given string.
+
+Examples:
+
+Input : S = "geeks"
+Output : geeks
+         eeksg
+         eksge
+         ksgee
+         sgeek
+
+Input : S = "abc"
+Output : abc
+         bca
+         cab
+'''
+
+#O(n^2)
+def printRotatedString(string):
+
+    n=len(string)
+
+    temp=string+string   # abcabc
+
+    for i in range(n):          # 0,1,2
+
+        for j in range(n):      # 0,1,2 | 0
+
+            print( temp[i+j],end="")   # a,b,c  | b,c,a | c,a,b
+        print()
+
+if __name__ == "__main__":
+    string = "abc"
+    printRotatedString(string)

String/__init__.py

@@ -0,0 +1,42 @@
+'''
+Reversing an Equation
+Difficulty Level : Basic
+Last Updated : 04 Jan, 2021
+Given a mathematical equation using numbers/variables and +, -, *, /. Print the equation in reverse.
+
+Examples:
+
+Input : 20 - 3 + 5 * 2
+Output : 2 * 5 + 3 - 20
+
+Input : 25 + 3 - 2 * 11
+Output : 11 * 2 - 3 + 25
+
+Input : a + b * c - d / e
+Output : e / d - c * b + a
+'''
+
+
+def reverseEquation(s):
+    # Reverse String
+    result = ""
+    for i in range(len(s)):
+
+        # A space marks the end of the word
+        if (s[i] == '+' or s[i] == '-' or s[i] == '/' or s[i] == '*'):
+
+            # insert the word at the beginning
+            # of the result String
+            result = s[i] + result
+
+        # insert the symbol
+        else:
+            # insert the word at the beginning
+            result = s[i] + result
+    return result
+
+
+if __name__ == '__main__':
+    # Driver Code
+    s = "a+b*c-d/e"
+    print(reverseEquation(s))