challenge-1-readme

challenege-13/number-1-bits.py

@@ -0,0 +1,14 @@
+class Solution:
+    def hammingWeight(self, n: int) -> int:
+        binn = []
+        while n > 0 :
+            bit = n % 2
+            binn.append(str(bit))
+            n //=2
+        binn.reverse()
+        s = "".join(binn)
+        ans = 0
+        for i in s:
+            if i == "1":
+                ans +=1
+        return ans

challenege-20/longest-common-subseqence.py

@@ -0,0 +1,18 @@
+class Solution:
+    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
+        memo = {}
+
+        def dfs(i, j):
+            if i == len(text1) or j == len(text2):
+                return 0
+            if (i, j) in memo:
+                return memo[(i, j)]
+
+            if text1[i] == text2[j]:
+                memo[(i, j)] = 1 + dfs(i + 1, j + 1)
+            else:
+                memo[(i, j)] = max(dfs(i + 1, j), dfs(i, j + 1))
+
+            return memo[(i, j)]
+
+        return dfs(0, 0)

challenege-22/combination-sum-IV.py

@@ -0,0 +1,10 @@
+class Solution:
+    def combinationSum4(self, nums: List[int], target: int) -> int:
+        dp = [0] * (target + 1)
+        dp[0] = 1
+        for currentSum in range(1, target + 1):
+            for numIndex in range(0, len(nums)):
+                currentNum = nums[numIndex]
+                if currentSum - currentNum >= 0:
+                    dp[currentSum] += dp[currentSum - currentNum]
+        return dp[target]

challenege-23/house-robber.py

@@ -0,0 +1,19 @@
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        dp = [-1] * (len(nums)+1)
+        def helper (nums , ind):
+            if ind == 0:
+                return nums[0]
+            if ind < 0:
+                return 0
+            if dp[ind] == -1:
+                pick = nums[ind] + helper(nums , ind-2)
+                notPick = 0 + helper(nums,ind-1) 
+                dp[ind] = max(pick ,notPick)
+            return dp[ind]
+        return helper(nums,len(nums)-1)
+
+
+
+
+

challenege-24/house-robber-2.py

@@ -0,0 +1,11 @@
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+
+        def helper(ls):
+            temp , prevMax = 0 , 0 
+            for n in ls:
+                newMax = max(temp+n,prevMax)
+                temp = prevMax
+                prevMax = newMax
+            return prevMax
+        return max(nums[0] , helper(nums[1:]) , helper(nums[:-1]))

challenege-27/jump-game.py

@@ -0,0 +1,7 @@
+class Solution:
+    def canJump(self, nums: List[int]) -> bool:
+        g = len(nums) -1
+        for i in range(len(nums)-1,-1,-1):
+            if i+nums[i] >= g:
+                g = i
+        return True if g==0 else False

challenege-28/clone-graph.py

@@ -0,0 +1,23 @@
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val = 0, neighbors = None):
+        self.val = val
+        self.neighbors = neighbors if neighbors is not None else []
+"""
+
+from typing import Optional
+class Solution:
+    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
+        hm = {}
+        def clone(node):
+            if node in hm:
+                return hm[node]
+            copy = Node(node.val)
+            hm[node] = copy
+            for n in node.neighbors:
+                copy.neighbors.append(clone(n))
+            return copy
+        return clone(node) if node else None
+
+

challenege-31/number-of-islands.py

@@ -0,0 +1,23 @@
+class Solution:
+    def numIslands(self, grid: List[List[str]]) -> int:
+        directions = [[1, 0], [-1, 0], [0, 1], [0, -1]]
+        ROWS, COLS = len(grid), len(grid[0])
+        islands = 0
+
+        def dfs(r, c):
+            if (r < 0 or c < 0 or r >= ROWS or 
+                c >= COLS or grid[r][c] == "0"
+            ):
+                return
+
+            grid[r][c] = "0"
+            for dr, dc in directions:
+                dfs(r + dr, c + dc)
+
+        for r in range(ROWS):
+            for c in range(COLS):
+                if grid[r][c] == "1":
+                    dfs(r, c)
+                    islands += 1
+
+        return islands

challenege-32/longest-consective-sequence.java

@@ -0,0 +1,20 @@
+import java.util.*;
+class Solution {
+    public int longestConsecutive(int[] nums) {
+        int l = 0;
+       HashSet<Integer> hs = new HashSet<Integer>();
+       for (int n: nums){
+        hs.add(n);
+       }
+        for (int n :hs){
+            if(!hs.contains(n-1)){
+                int t = 0;
+                while (hs.contains(n + t)) {
+                    t++;
+                }
+                l = Math.max(t, l);
+            }
+        }
+        return l;
+    }
+}

challenege-33/FInd-building-where-alice-and-bob-meet.py

@@ -0,0 +1,13 @@
+class Solution:
+    def leftmostBuildingQueries(self, h: List[int], q: List[List[int]]) -> List[int]:
+        res = [-1] * len(q)
+        for i,k in enumerate(q):
+            l,r = sorted(k)
+            if l == r or h[l] < h[r]:
+                res[i] = r
+                continue
+            for j in range(r+1,len(h)):
+                if h[j] > max(h[l],h[r]):
+                    res[i]  = j
+                    break
+        return res

challenege-38/non-overlapping-intervals.py

@@ -0,0 +1,14 @@
+class Solution:
+    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
+        intervals.sort()
+
+        res = 0
+        prev = intervals[0][1]
+        for s,e in intervals[1:]:
+            if s >= prev:
+                prev = e
+            else:
+                res+=1
+                prev = min(prev,e)
+        return res
+

challenege-40/meeting-rooms-2.py

@@ -0,0 +1,19 @@
+"""
+Definition of Interval:
+class Interval(object):
+    def __init__(self, start, end):
+        self.start = start
+        self.end = end
+"""
+
+class Solution:
+    def minMeetingRooms(self, intervals: List[Interval]) -> int:
+        intervals.sort(key=lambda x: x.start)
+        min_heap = []
+
+        for interval in intervals:
+            if min_heap and min_heap[0] <= interval.start:
+                heapq.heappop(min_heap)
+            heapq.heappush(min_heap, interval.end)
+
+        return len(min_heap)

challenege-42/detect-cycle-in-linked-list.java

@@ -0,0 +1,27 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public boolean hasCycle(ListNode head) {
+        if(head==null){
+            return false;
+        }
+        ListNode slow = head, fast = head.next;
+        while(fast!=null && fast.next!=null){
+            if(slow == fast){
+                return true;
+            }
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        return false;
+    }
+}

challenege-43/merge-two-sorted-list.py

@@ -0,0 +1,18 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+
+class Solution:
+    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
+        if list1 is None:
+            return list2
+        if list2 is None:
+            return list1
+        if list1.val <= list2.val:
+            list1.next = self.mergeTwoLists(list1.next, list2)
+            return list1
+        else:
+            list2.next = self.mergeTwoLists(list1, list2.next)
+            return list2

challenege-45/remove-nth-node-from-end-of-list.py

@@ -0,0 +1,20 @@
+# 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]:
+        nodes = []
+        cur = head
+        while cur:
+            nodes.append(cur)
+            cur = cur.next
+
+        removeIndex = len(nodes) - n
+        if removeIndex == 0:
+            return head.next
+
+        nodes[removeIndex - 1].next = nodes[removeIndex].next
+        return head

challenege-46/reorder-list.py

@@ -0,0 +1,27 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+
+class Solution:
+    def reorderList(self, head: Optional[ListNode]) -> None:
+        slow, fast = head, head.next
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+
+        second = slow.next
+        prev = slow.next = None
+        while second:
+            tmp = second.next
+            second.next = prev
+            prev = second
+            second = tmp
+
+        first, second = head, prev
+        while second:
+            tmp1, tmp2 = first.next, second.next
+            first.next = second
+            second.next = tmp1
+            first, second = tmp1, tmp2

challenege-47/set-zero.py

@@ -0,0 +1,16 @@
+class Solution:
+    def setZeroes(self, matrix: List[List[int]]) -> None:
+        ROWS, COLS = len(matrix), len(matrix[0])
+        mark = [[matrix[r][c] for c in range(COLS)] for r in range(ROWS)]
+
+        for r in range(ROWS):
+            for c in range(COLS):
+                if matrix[r][c] == 0:
+                    for col in range(COLS):
+                        mark[r][col] = 0
+                    for row in range(ROWS):
+                        mark[row][c] = 0
+
+        for r in range(ROWS):
+            for c in range(COLS):
+                matrix[r][c] = mark[r][c]

challenege-48/spiral-matrix.py

@@ -0,0 +1,23 @@
+class Solution:
+    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
+        res = []
+        left, right = 0, len(matrix[0])
+        top, bottom = 0, len(matrix)
+
+        while left < right and top < bottom:
+            for i in range(left, right):
+                res.append(matrix[top][i])
+            top += 1
+            for i in range(top, bottom):
+                res.append(matrix[i][right - 1])
+            right -= 1
+            if not (left < right and top < bottom):
+                break
+            for i in range(right - 1, left - 1, -1):
+                res.append(matrix[bottom - 1][i])
+            bottom -= 1
+            for i in range(bottom - 1, top - 1, -1):
+                res.append(matrix[i][left])
+            left += 1
+
+        return res

challenege-50/word-search.py

@@ -0,0 +1,25 @@
+class Solution:
+    def exist(self, board: List[List[str]], word: str) -> bool:
+        ROWS, COLS = len(board), len(board[0])
+        visited = [[False for _ in range(COLS)] for _ in range(ROWS)]
+
+        def dfs(r, c, i):
+            if i == len(word):
+                return True
+            if (r < 0 or c < 0 or r >= ROWS or c >= COLS or
+                word[i] != board[r][c] or visited[r][c]):
+                return False
+
+            visited[r][c] = True
+            res = (dfs(r + 1, c, i + 1) or
+                   dfs(r - 1, c, i + 1) or
+                   dfs(r, c + 1, i + 1) or
+                   dfs(r, c - 1, i + 1))
+            visited[r][c] = False
+            return res
+
+        for r in range(ROWS):
+            for c in range(COLS):
+                if dfs(r, c, 0):
+                    return True
+        return False

challenege-51/longest-substring-without-repeating-character.py

@@ -0,0 +1,12 @@
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        charset = set()
+        l = 0
+        res = 0
+        for r in range(len(s)):
+            while s[r] in charset:
+                charset.remove(s[l])
+                l+=1
+            charset.add(s[r])
+            res = max(res, r-l + 1)
+        return res