first commit

Author: Bishal16

167. Two Sum II - Input Array Is Sorted.py

@@ -0,0 +1,8 @@
+class Solution:
+    def twoSum(self, numbers: List[int], target: int) -> List[int]:
+        hash = {}
+        for pos in range(len(numbers)):
+            if target-numbers[pos] in hash:
+                return [hash[target-numbers[pos]]+1, pos+1]
+            else:
+                hash[numbers[pos]] = pos

189. Rotate Array.py

@@ -0,0 +1,7 @@
+class Solution:
+    def rotate(self, nums: List[int], k: int) -> None:
+        """
+        Do not return anything, modify nums in-place instead.
+        """
+        ln, k = len(nums), k % len(nums)
+        nums[:] = nums[ln-k:] + nums[0:ln-k]

19. Remove Nth Node From End of List.py

@@ -0,0 +1,24 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
+        node = head
+        total = 0
+        while node:
+            total += 1
+            node = node.next
+        if total == 1:
+            return None
+        elif total == n:
+            return head.next
+        total = total - n
+        node = head
+        x=1
+        while x< total:
+            node= node.next
+            x+=1
+        node.next = node.next.next
+        return head

283. Move Zeroes.py

@@ -0,0 +1,15 @@
+class Solution:
+    def moveZeroes(self, nums: List[int]) -> None:
+        """
+        Do not return anything, modify nums in-place instead.
+        """
+        i=0
+        ln = len(nums)
+        while i < ln:
+            if nums[i] == 0:
+                nums.pop(i)
+                nums.append(0)
+                i-=1
+                ln-=1            
+            i+=1
+        return nums

3. Longest Substring Without Repeating Characters.py

@@ -0,0 +1,17 @@
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:        
+        ln = len(s)
+        max = 0
+        for i in range(ln):
+            hash = {}
+            tmp = 0
+            for j in range(i,ln):
+                if s[j] not in hash:
+                    hash[s[j]] = s[j]
+                    tmp+=1
+                else:                    
+                    break   
+            if tmp > max:
+                max = tmp
+            hash.clear()
+        return max

344. Reverse String.py

@@ -0,0 +1,11 @@
+class Solution:
+    def reverseString(self, s: List[str]) -> None:
+        """
+        Do not return anything, modify s in-place instead.
+        """
+        ln = len(s) 
+        
+        for i in range(int(ln/2)):
+            tmp = s[i]
+            s[i] = s[ln-i-1]
+            s[ln-i-1] = tmp

35. Search Insert Position.py

@@ -0,0 +1,6 @@
+class Solution:
+    def searchInsert(self, nums: List[int], target: int) -> int:
+        for i,val in enumerate(nums):
+            if target==val or target<val:
+                return i            
+        return i+

567. Permutation in String.py

@@ -0,0 +1,50 @@
+class Solution:
+#     def checkInclusion(self, s1: str, s2: str) -> bool:
+#         s1 = ''.join(sorted(s1))
+#         l1 , l2= len(s1), len(s2)
+#         r1, r2 = 0, l1
+        
+#         while r2 <= l2:            
+#             if s1  == ''.join(sorted(s2[r1:r2])):
+#                 return True
+#             r1+=1
+#             r2+=1
+#         return False
+        #approach 2
+        def checkInclusion(self, s1: str, s2: str) -> bool:
+            hash1 = {}
+            # for i in range(97,123):
+            #     hash1[chr(i)] = 0
+            for i in s1:                
+                if i in hash1:
+                    hash1[i] += 1
+                else:
+                    hash1[i] = 1
+            # print(hash1)
+            
+            l1 , l2= len(s1), len(s2)
+            r1, r2 = 0, l1
+            while r2 <= l2:   
+                hash2 = {}
+                x = s2[r1 : r2]
+                for i in range(r1,r2):
+                    
+                    if s2[i] in hash2:
+                        hash2[s2[i]] += 1
+                    else:
+                        hash2[s2[i]] = 1                    
+                c=0
+                # for i in s1:
+                #     if i not in hash2.keys():
+                #         break
+                #     elif hash1[i] == hash2[i]:
+                #         c+=1
+                # if c == l1:
+                #     return True
+                # or simply
+                if hash1==hash2:
+                    return True
+                        
+                r1+=1
+                r2+=1
+            return False

695. Max Area of Island.py

@@ -0,0 +1,53 @@
+class Solution:    
+    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
+        
+        # make all node unvisited at first
+        r , n = len(grid), len(grid[0])
+        visited=[]
+        for i in range(r):  
+            t=[]
+            for j in range(n):
+                t.append(0)
+            visited.append(t)
+
+        max = 0 # initialize maxirur island area = 0
+        for i in range(r):
+            for j in range(n):                    
+                self.max = 0
+                if grid[i][j] == 1 and visited[i][j] == 0: # check only land which is unvisited
+                    visited[i][j] = 1
+                    self.max += 1
+                    
+                    def dfs(x,y):
+                        # check right node
+                        if y < n-1 :
+                            if grid[x][y+1] == 1 and visited[x][y+1] == 0:
+                                self.max += 1
+                                visited[x][y+1] = 1
+                                dfs(x, y+1)
+                        # check bottom node
+                        if x < r-1 :                            
+                            if grid[x+1][y] == 1 and visited[x+1][y] == 0:
+                                self.max += 1
+                                visited[x+1][y] = 1
+                                dfs(x+1,y)
+                        # check left node
+                        if y > 0 :
+                            if grid[x][y-1] == 1 and visited[x][y-1] == 0:
+                                self.max += 1
+                                visited[x][y-1] = 1
+                                dfs(x, y-1)
+                        # check top node
+                        if x > 0 :
+                            if grid[x-1][y] == 1 and visited[x-1][y] == 0:
+                                self.max += 1
+                                visited[x-1][y] = 1
+                                dfs(x-1, y)
+                        return self.max                                  
+                    area = dfs(i,j)
+                    if area > max:
+                        max = area                    
+        return max
+                
+                
+                

704. Binary Search.py

@@ -0,0 +1,15 @@
+class Solution:
+    def search(self, nums: List[int], target: int) -> int:
+        end = len(nums)-1
+        start = 0
+        while(start<= end):
+            mid = (start+end)//2
+            if nums[mid] == target:
+                return mid
+            elif target >= nums[start] and target <= nums[mid]:
+                end = mid
+            elif target > nums[mid] and target <= nums[end]:
+                start = mid+1                
+            else :
+                return -1
+