:squirrel:

Author: angelgladin

Diff for: 3sum.py

@@ -0,0 +1,28 @@
+# 15. 3Sum
+# https://leetcode.com/problems/3sum/
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+        n = len(nums)
+        ans = []
+        for i in range(n-2):
+            if i > 0 and nums[i] == nums[i-1]:
+                continue
+            j = i+1
+            k = n-1
+            while j < k:
+                s = nums[i] + nums[j] + nums[k]
+                if s == 0:
+                    ans.append([nums[i], nums[j], nums[k]])
+                    while j < k and nums[j] == nums[j+1]:
+                        j += 1
+                    while j < k and nums[k] == nums[k-1]:
+                        k -= 1
+                    j += 1
+                    k -= 1
+                elif s > 0:
+                    k -= 1
+                else:
+                    j += 1
+        return ans

Diff for: accounts-merge.py

@@ -0,0 +1,37 @@
+# 721. Accounts Merge
+# https://leetcode.com/problems/accounts-merge/
+
+from collections import defaultdict
+class Solution:
+    def accountsMerge(self, accounts: List[List[str]]) -> List[List[str]]:
+        def dfs(stack, emails, explored, graph):
+            while stack:
+                u = stack.pop()
+                emails.append(u)
+                for v in graph[u]:
+                    if v not in explored:
+                        explored.add(v)
+                        stack.append(v)
+        
+        graph = defaultdict(set)
+        email_to_name = dict()
+        for account in accounts:
+            name = account[0]
+            for i in range(1, len(account)):
+                email_to_name[account[i]] = name
+                if i == 1:
+                    continue
+                graph[account[i]].add(account[i-1])
+                graph[account[i-1]].add(account[i])
+
+        explored = set()
+        ans = []
+        for email in email_to_name.keys():
+            if email not in explored:
+                explored.add(email)
+                stack = [email]
+                emails = []
+                dfs(stack, emails, explored, graph)
+                emails.sort()
+                ans.append([email_to_name[email]] + emails)
+        return ans

Diff for: add-binary.py

@@ -1,3 +1,4 @@
+# 67. Add Binary
 # https://leetcode.com/problems/add-binary/
 
 class Solution:

Diff for: add-two-numbers.py

@@ -1,3 +1,4 @@
+# 2. Add Two Numbers
 # https://leetcode.com/problems/add-two-numbers/
 
 # Definition for singly-linked list.

Diff for: alien-dictionary.py

@@ -1,3 +1,6 @@
+# 269. Alien Dictionary
+# https://leetcode.com/problems/alien-dictionary/
+
 class Solution:
     def alienOrder(self, words: List[str]) -> str:
         from collections import defaultdict

Diff for: backspace-string-compare.py

@@ -1,3 +1,4 @@
+# 844. Backspace String Compare
 # https://leetcode.com/problems/backspace-string-compare/
 
 class Solution:

Diff for: binary-search-tree-iterator.py

@@ -1,3 +1,4 @@
+# 173. Binary Search Tree Iterators
 # https://leetcode.com/problems/binary-search-tree-iterator/
 
 # Definition for a binary tree node.

Diff for: combination-sum-ii.py

@@ -1,3 +1,4 @@
+# 40. Combination Sum II
 # https://leetcode.com/problems/combination-sum-ii/
 
 class Solution:

Diff for: combination-sum.py

@@ -0,0 +1,18 @@
+# 39. Combination Sum
+# https://leetcode.com/problems/combination-sum/
+
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        def backtrack(l, k, s, idx, n, aux, ans):
+            if s == k:
+                ans.append(aux[:])
+            elif s > k:
+                return
+            for i in range(idx, n):
+                aux.append(l[i])
+                backtrack(l, k, s+l[i], i, n, aux, ans)
+                aux.pop()
+        
+        ans = []
+        backtrack(candidates, target, 0, 0, len(candidates), [], ans)
+        return ans

Diff for: confusing-number.py

@@ -1,3 +1,4 @@
+# 1056. Confusing Number
 # https://leetcode.com/problems/confusing-number/
 
 class Solution:

Diff for: design-phone-directory.py

@@ -1,3 +1,4 @@
+# 379. Design Phone Directory
 # https://leetcode.com/problems/design-phone-directory/
 
 class PhoneDirectory:

Diff for: diameter-of-binary-tree.py

@@ -1,3 +1,4 @@
+# 543. Diameter of Binary Tree
 # https://leetcode.com/problems/diameter-of-binary-tree/
 
 # Definition for a binary tree node.

Diff for: find-all-anagrams-in-a-string.py

@@ -0,0 +1,31 @@
+# 438. Find All Anagrams in a String
+# https://leetcode.com/problems/find-all-anagrams-in-a-string/
+
+class Solution:
+    def findAnagrams(self, s: str, p: str) -> List[int]:
+        def equals(w1, w2, n):
+            for i in range(26):
+                if w1[i] != w2[i]:
+                    return False
+            return True
+        
+        if not s or len(s) < len(p):
+            return []
+
+        ns, np = len(s), len(p)
+        w1, w2 = [0]*26, [0]*26
+        ans = []
+        idx = lambda x: ord(x) - ord('a')
+        
+        for i in range(np):
+            w1[idx(s[i])] += 1
+            w2[idx(p[i])] += 1
+        
+        for i in range(ns-np+1):
+            if equals(w1, w2, np):
+                ans.append(i)
+            w1[idx(s[i])] -= 1
+            if i+np < ns:
+                w1[idx(s[i+np])] += 1
+        
+        return ans

Diff for: find-and-replace-in-string.py

@@ -1,3 +1,4 @@
+# 833. Find And Replace in String
 # https://leetcode.com/problems/find-and-replace-in-string/
 
 class Solution:

Diff for: first-bad-version.py

@@ -1,3 +1,4 @@
+# 278. First Bad Version
 # https://leetcode.com/problems/first-bad-version/
 
 # The isBadVersion API is already defined for you.

Diff for: flip-equivalent-binary-trees.py

@@ -1,3 +1,4 @@
+# 951. Flip Equivalent Binary Trees
 # https://leetcode.com/problems/flip-equivalent-binary-trees/
 
 # Definition for a binary tree node.

Diff for: guess-number-higher-or-lower.py

@@ -1,3 +1,4 @@
+# 374. Guess Number Higher or Lower
 # https://leetcode.com/problems/guess-number-higher-or-lower/
 
 # The guess API is already defined for you.

Diff for: integer-to-english-words.py

@@ -0,0 +1,91 @@
+# 273. Integer to English Words
+# https://leetcode.com/problems/integer-to-english-words/
+
+class Solution:
+    def numberToWords(self, num: int) -> str:
+        def ones_n(n):
+            f = {
+                1 : 'One',
+                2 : 'Two',
+                3 : 'Three',
+                4 : 'Four',
+                5 : 'Five',
+                6 : 'Six',
+                7 : 'Seven',
+                8 : 'Eight',
+                9 : 'Nine'
+            }
+            return f[n]
+        
+        def tens_less_twenty_n(n):
+            f = {
+                10 : 'Ten',
+                11 : 'Eleven',
+                12 : 'Twelve',
+                13 : 'Thirteen',
+                14 : 'Fourteen',
+                15 : 'Fifteen',
+                16 : 'Sixteen',
+                17 : 'Seventeen',
+                18 : 'Eighteen',
+                19 : 'Nineteen'
+            }
+            return f[n]
+        
+        def tens_n(n):
+            f = {
+                2 : 'Twenty',
+                3 : 'Thirty',
+                4 : 'Forty',
+                5 : 'Fifty',
+                6 : 'Sixty',
+                7 : 'Seventy',
+                8 : 'Eighty',
+                9 : 'Ninety'
+            }
+            return f[n]
+        
+        def tens(n):
+            if n == 0:
+                return ''
+            if n < 10:
+                return ones_n(n)
+            elif n > 9 and n < 20:
+                return tens_less_twenty_n(n)
+            else:
+                aux_tens = n // 10
+                rest = n % 10
+                return tens_n(aux_tens) + ('' if rest == 0 else ' ' + ones_n(rest))
+        
+        def hundreds(n):
+            if n == 0:
+                return ''
+            s = ''
+            aux_hundreds = n // 100
+            if aux_hundreds != 0:
+                s += ones_n(aux_hundreds) + ' Hundred'
+            tens_aux = n - (aux_hundreds * 100)
+            if tens_aux != 0:
+                s += ' ' if aux_hundreds != 0 else ''
+                s += tens(tens_aux)
+            return s
+        
+        n = num
+        billion = n // int(1e9)
+        million = (n - (billion * int(1e9))) // int(1e6)
+        thousand = (n - (billion * int(1e9)) - (million * int(1e6))) // int(1e3)
+        rest =  n - (billion * int(1e9)) - (million * int(1e6)) - (thousand * int(1e3))
+        
+        s = ''
+        if billion != 0:
+            s += hundreds(billion) + ' Billion'
+        if million != 0:
+            s += ' ' if s else ''
+            s += hundreds(million) + ' Million'
+        if thousand != 0:
+            s += ' ' if s else ''
+            s += hundreds(thousand) + ' Thousand'
+        if rest != 0:
+            s += ' ' if s else ''
+            s += hundreds(rest)
+        return 'Zero' if n == 0 else s

Diff for: intersection-of-two-arrays-ii.py

@@ -1,3 +1,6 @@
+# 350. Intersection of Two Arrays II
+# https://leetcode.com/problems/intersection-of-two-arrays-ii/
+
 class Solution:
     def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
         nums1.sort()

Diff for: intersection-of-two-arrays.py

@@ -0,0 +1,20 @@
+# 349. Intersection of Two Arrays
+# https://leetcode.com/problems/intersection-of-two-arrays/
+
+class Solution:
+    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
+        nums1.sort()
+        nums2.sort()
+        ans = set()
+        n1, n2 = len(nums1), len(nums2)
+        i, j = 0, 0
+        while i < n1 and j < n2:
+            if nums1[i] < nums2[j]:
+                i += 1
+            elif nums1[i] > nums2[j]:
+                j += 1
+            else:
+                ans.add(nums1[i])
+                i += 1
+                j += 1
+        return ans

Diff for: is-graph-bipartite.py

@@ -0,0 +1,22 @@
+# 785. Is Graph Bipartite?
+# https://leetcode.com/problems/is-graph-bipartite/
+
+class Solution:
+    def isBipartite(self, graph: List[List[int]]) -> bool:
+        n = len(graph)
+        NOT_EXPLORED, RED, BLUE = -1, 0, 1
+        color = [NOT_EXPLORED]*n
+        for u in range(n):
+            if color[u] == NOT_EXPLORED:
+                color[u] = RED
+                stack = []
+                stack.append(u)
+                while stack:
+                    curr = stack.pop()
+                    for v in graph[curr]:
+                        if color[v] == NOT_EXPLORED:
+                            color[v] = BLUE if color[curr] == RED else RED
+                            stack.append(v)
+                        elif color[curr] == color[v]:
+                            return False
+        return True

Diff for: isomorphic-strings.py

@@ -1,3 +1,4 @@
+# 205. Isomorphic Strings
 # https://leetcode.com/problems/isomorphic-strings/
 
 class Solution:

Diff for: k-closest-points-to-origin.py

@@ -1,3 +1,4 @@
+# 973. K Closest Points to Origin
 # https://leetcode.com/problems/k-closest-points-to-origin/
 
 class Solution:

Diff for: letter-combinations-of-a-phone-number.py

@@ -1,3 +1,4 @@
+# 17. Letter Combinations of a Phone Number
 # https://leetcode.com/problems/letter-combinations-of-a-phone-number/
 
 class Solution:

Diff for: longest-palindromic-substring.py

@@ -1,3 +1,4 @@
+# 5. Longest Palindromic Substring
 # https://leetcode.com/problems/longest-palindromic-substring/
 
 class Solution:

Diff for: longest-substring-without-repeating-characters.py

@@ -1,3 +1,4 @@
+# 3. Longest Substring Without Repeating Characters
 # https://leetcode.com/problems/longest-substring-without-repeating-characters/
 
 class Solution:

Diff for: merge-intervals.py

@@ -1,3 +1,4 @@
+# 56. Merge Intervals
 # https://leetcode.com/problems/merge-intervals/
 
 class Solution:

Diff for: merge-k-sorted-lists.py

@@ -1,3 +1,6 @@
+# 23. Merge k Sorted Lists
+# https://leetcode.com/problems/merge-k-sorted-lists/
+
 # Definition for singly-linked list.
 # class ListNode:
 #     def __init__(self, x):

Diff for: merge-sorted-array.py

@@ -1,3 +1,4 @@
+# 88. Merge Sorted Array
 # https://leetcode.com/problems/merge-sorted-array/
 
 class Solution:

Diff for: minimum-depth-of-binary-tree.py

@@ -1,3 +1,4 @@
+# 111. Minimum Depth of Binary Tree
 # https://leetcode.com/problems/minimum-depth-of-binary-tree/
 
 # Definition for a binary tree node.

Diff for: move-zeroes.py

@@ -1,3 +1,4 @@
+# 283. Move Zeroes
 # https://leetcode.com/problems/move-zeroes/
 
 class Solution:

Diff for: next-closest-time.py

@@ -1,3 +1,4 @@
+# 681. Next Closest Time
 # https://leetcode.com/problems/next-closest-time/
 
 class Solution: