Add comprehensive LeetCode solutions index documentation

src/exercises/1.two-sum.py

@@ -0,0 +1,56 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet start
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        num_len = len(nums)
+        if num_len == 0:
+            return []
+        if num_len == 1:
+            return [0]
+        if num_len == 2:
+            return [0, 1]
+        arr = []
+        hash_map = {}
+        for i in range(num_len):
+            complement = target - nums[i]
+            if complement in hash_map:
+                return [i, hash_map[complement]]
+            hash_map[nums[i]] = i
+
+        return arr
+
+# @leet end

src/exercises/10.regular-expression-matching.py

@@ -0,0 +1,40 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet start
+class Solution:
+    def isMatch(self, s: str, p: str) -> bool:
+        
+# @leet end

src/exercises/11.container-with-most-water.py

@@ -0,0 +1,53 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        i, j, max_vol = 0, len(height) - 1, 0
+        while i < j:
+            if height[i] > height[j]:
+                max_vol = max(max_vol, min(height[i], height[j]) * (j - i))
+                j -= 1
+            elif height[j] >= height[i]:
+                max_vol = max(max_vol, min(height[i], height[j]) * (j - i))
+                i += 1
+
+        return max_vol
+
+
+# @leet end
+

src/exercises/1200.minimum-absolute-difference.py

@@ -0,0 +1,55 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def minimumAbsDifference(self, arr: List[int]) -> List[List[int]]:
+        arr.sort()
+        min_abs = float(inf)
+        ans = []
+        for i in range(len(arr) - 1):
+            abs_sum = abs(arr[i] - arr[i + 1])
+            if abs_sum < min_abs:
+                ans = []
+                min_abs = abs_sum
+                ans.append([arr[i], arr[i + 1]])
+            elif abs_sum == min_abs:
+                ans.append([arr[i], arr[i + 1]])
+
+        return ans
+
+
+# @leet end

src/exercises/121.best-time-to-buy-and-sell-stock.py

@@ -0,0 +1,50 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        max_profit = 0
+        min_price = float(inf)
+        for price in prices:
+            min_price = price if price < min_price else min_price
+            profit = price - min_price
+            max_profit = profit if max_profit < profit else max_profit
+        return max_profit
+
+
+# @leet end
+

src/exercises/122.best-time-to-buy-and-sell-stock-ii.py

@@ -0,0 +1,56 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet imports end
+
+
+# @leet start
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        p = 0
+        buy = prices[0]
+            
+        for i in range(1, len(prices), +1):
+            r = prices[i] - buy
+            if r > 0:
+                p += r
+            buy = prices[i]
+
+        return p
+
+
+# @leet end
+

src/exercises/125.valid-palindrome.py

@@ -0,0 +1,47 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def isPalindrome(self, s: str) -> bool:
+        s = re.sub(r"[^a-zA-Z0-9]", "", s)
+        s = s.lower()
+        new_s = s[::-1]
+        return s == new_s
+
+
+# @leet end
+

src/exercises/128.longest-consecutive-sequence.py

@@ -0,0 +1,62 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet start
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        if len(nums) < 2:
+            return len(nums)
+        consecutive = set(nums)
+        consecutive = sorted(consecutive)
+        counter = [0] * len(consecutive)
+        count = 1
+        k = 0
+        for i in range(len(consecutive)):
+            if i == 0:
+                counter[k] = count
+                continue
+            if consecutive[i] == consecutive[i - 1] + 1:
+                count += 1
+            else:
+                count = 1
+                k += 1
+            counter[k] = count
+        max_num = 0
+        counter = [i for i in counter if i > 0]
+        for num in counter:
+            max_num = max(max_num, num)
+        return max_num
+        
+# @leet end

src/exercises/1298.maximum-candies-you-can-get-from-boxes.py

@@ -0,0 +1,40 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet start
+class Solution:
+    def maxCandies(self, status: List[int], candies: List[int], keys: List[List[int]], containedBoxes: List[List[int]], initialBoxes: List[int]) -> int:
+        
+# @leet end

src/exercises/13.roman-to-integer.py

@@ -0,0 +1,67 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# * I can be placed before V (5) and X (10) to make 4 and 9.
+# * X can be placed before L (50) and C (100) to make 40 and 90.
+# * C can be placed before D (500) and M (1000) to make 400 and 900.
+
+# @leet start
+class Solution:
+    def romanToInt(self, s: str) -> int:
+        numbers = {"I": 1, "V": 5, "X": 10, "L": 50, "C": 100, "D": 500, "M": 1000}
+        count = 0
+        i = len(s) - 1
+        while i > -1:
+            if i == 0:
+                count += numbers[s[i]]
+            elif (
+                (s[i] == "V" and s[i - 1] == "I")
+                or (s[i] == "X" and s[i - 1] == "I")
+                or (s[i] == "C" and s[i - 1] == "X")
+                or (s[i] == "L" and s[i - 1] == "X")
+                or (s[i] == "D" and s[i - 1] == "C")
+                or (s[i] == "M" and s[i - 1] == "C")
+            ):
+                val = numbers[s[i]] - numbers[s[i - 1]]
+                count += val
+                i -= 1
+            else:
+                count += numbers[s[i]]
+            i -= 1
+
+        return count
+
+
+# @leet end

src/exercises/135.candy.py

@@ -0,0 +1,53 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def candy(self, ratings: List[int]) -> int:
+        arr = [1] * len(ratings)
+        for i in range(1, len(ratings)):
+            if ratings[i] > ratings[i - 1]:
+                arr[i] = arr[i - 1] + 1
+
+        for i in range(len(ratings) - 2, -1, -1):
+            if ratings[i] > ratings[i + 1]:
+                arr[i] = max(arr[i], arr[i + 1] + 1)
+
+        return sum(arr)
+
+
+# @leet end
+

src/exercises/14.longest-common-prefix.py

@@ -0,0 +1,66 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class TrieNode:
+    def __init__(self):
+        self.children = {}
+        self.is_end_of_word = False
+
+
+class Solution:
+    def longestCommonPrefix(self, strs: List[str]) -> str:
+        if len(strs) < 1:
+            return ""
+        if len(strs) == 1:
+            return strs[0]
+        m = float(inf)
+        for w in strs:
+            m = len(w) if len(w) < m else m
+        for i in range(len(strs)):
+            strs[i] = strs[i][:m]
+
+        h = m
+        for i in range(m - 1, -1, -1):
+            current = strs[0][i]
+            for j in range(1, len(strs), +1):
+                if strs[j][i] != current:
+                    h = i
+
+        return strs[0][:h]
+
+
+# @leet end

src/exercises/141.linked-list-cycle.py

@@ -0,0 +1,48 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+# @leet imports end
+
+# @leet start
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+        
+# @leet end

src/exercises/149.max-points-on-a-line.py

@@ -0,0 +1,75 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet imports end
+
+
+# @leet start
+class Solution:
+    def maxPoints(self, points: List[List[int]]) -> int:
+        if len(points) <= 2:
+            return len(points)
+        i = 0
+        mx = float(-inf)
+        j = len(points) - 1
+
+        def getM(i, j):
+            y1 = points[i][1]
+            y2 = points[j][1]
+            x1 = points[i][0]
+            x2 = points[j][0]
+            if x2 - x1 == 0:
+                mm = float(inf)
+            else:
+                mm = (y2 - y1) / (x2 - x1)
+            return mm
+
+        for i in range(len(points) - 1):
+            m = {}
+            for j in range(i + 1, len(points), +1):
+                mm = getM(i, j)
+                if mm not in m:
+                    m[mm] = 1
+                else:
+                    m[mm] += 1
+            lmx = max(m.values() if m else 0)
+            mx = max(mx, lmx + 1)
+
+        return mx
+
+
+# @leet end
+

src/exercises/15.3sum.py

@@ -0,0 +1,68 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+        n = len(nums)
+        arr = []
+        for i in range(0, len(nums) - 1):
+            j = i + 1
+            k = n - 1
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+            while j < k:
+                sum = nums[j] + nums[i] + nums[k]
+                if sum == 0:
+                    val = [nums[i], nums[j], nums[k]]
+                    val.sort()
+                    arr.append(val)
+                    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 sum < 0:
+                    j += 1
+                elif sum > 0:
+                    k -= 1
+        return arr
+
+
+# @leet end
+

src/exercises/150.evaluate-reverse-polish-notation.py

@@ -0,0 +1,40 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet start
+class Solution:
+    def evalRPN(self, tokens: List[str]) -> int:
+        
+# @leet end

src/exercises/153.find-minimum-in-rotated-sorted-array.py

@@ -0,0 +1,54 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        l = 0
+        h = len(nums) - 1
+        while l <= h:
+            if l == h:
+                return nums[l]
+            mid = (l + h) // 2
+            if nums[mid] > nums[h]:
+                l = mid + 1
+            else:
+                h = mid
+
+
+
+# @leet end
+

src/exercises/155.min-stack.py

@@ -0,0 +1,69 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class MinStack:
+
+    def __init__(self):
+        self.stack = deque()
+        self.min = deque()
+
+    def push(self, val: int) -> None:
+        self.stack.append(val)
+        if not self.min or self.min[-1] >= val:
+            self.min.append(val)
+        else:
+            self.min.append(self.min[-1])
+
+    def pop(self) -> None:
+        self.stack.pop()
+        self.min.pop()
+
+    def top(self) -> int:
+        return self.stack[len(self.stack) - 1]
+
+    def getMin(self) -> int:
+        return self.min[-1]
+
+
+# Your MinStack object will be instantiated and called as such:
+# obj = MinStack()
+# obj.push(val)
+# obj.pop()
+# param_3 = obj.top()
+# param_4 = obj.getMin()
+# @leet end
+

src/exercises/167.two-sum-ii-input-array-is-sorted.py

@@ -0,0 +1,54 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet start
+class Solution:
+    def twoSum(self, numbers: List[int], target: int) -> List[int]:
+        i = 0
+        j = len(numbers) - 1
+        while i < j:
+            need = target - numbers[i]
+            if need == numbers[j]:
+                break
+            if need < numbers[j]:
+                j -= 1
+            elif need > numbers[i]:
+                i += 1
+            
+        return [i + 1, j + 1]
+
+
+        
+# @leet end

src/exercises/169.majority-element.py

@@ -0,0 +1,48 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet imports end
+
+
+# @leet start
+class Solution:
+    def majorityElement(self, nums: List[int]) -> int:
+       nums.sort() 
+       return nums[len(nums)//2]
+
+
+# @leet end
+

src/exercises/172.factorial-trailing-zeroes.py

@@ -0,0 +1,55 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet imports end
+
+
+# @leet start
+class Solution:
+    def trailingZeroes(self, n: int) -> int:
+        if n < 5:
+            return 0
+        z = 5
+        c = 0
+        while z <= n:
+            c += n // z
+            z *= 5
+
+        return c
+
+
+# @leet end
+

src/exercises/1820.maximum-number-of-accepted-invitations.py

@@ -0,0 +1,42 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+# @leet imports end
+
+# @leet start
+class Solution:
+    def maximumInvitations(self, grid: List[List[int]]) -> int:
+        
+# @leet end

src/exercises/189.rotate-array.py

@@ -0,0 +1,60 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+# @leet imports end
+
+# @leet start
+class Solution:
+    def rotate(self, nums: List[int], k: int) -> None:
+        """
+        Do not return anything, modify nums in-place instead.
+        """
+        if len(nums) <= 1:
+            return
+        
+        l = len(nums)
+        arr = [0] * l
+        k = k % len(nums) if k > len(nums) else k
+        j = 1
+        for i in range(l - 1, -1, -1):
+            x = k - j
+            if x < 0:
+                x += l
+            arr[x] = nums[i]
+            j += 1
+        for i in range(len(arr)):
+            nums[i] = arr[i]
+        
+# @leet end

src/exercises/2.add-two-numbers.py

@@ -0,0 +1,85 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def node(self, val, next=None):
+        self.val = val
+        self.next = next
+
+    def addTwoNumbers(
+        self, l1: Optional[ListNode], l2: Optional[ListNode]
+    ) -> Optional[ListNode]:
+        carry = 0
+        value_l1 = l1
+        value_l2 = l2
+        head = None
+        tail = None
+        while value_l1 or value_l2:
+            l2_val = l2.val if l2 else 0
+            l1_val = l1.val if l1 else 0
+            addition = l1_val + l2_val + carry
+            if addition > 9:
+                temp = str(addition)
+                carry = int(temp[0])
+                addition = int(temp[1])
+            else:
+                carry = 0
+            new_node = ListNode(addition)
+            if head is None:
+                head = new_node
+                tail = new_node
+            else:
+                tail.next = new_node
+                tail = new_node
+            value_l1 = l1.next if l1 else None
+            value_l2 = l2.next if l2 else None
+            l1 = l1.next if l1 else None
+            l2 = l2.next if l2 else None
+        if carry > 0:
+            new_node = ListNode(carry)
+            tail.next = new_node
+            tail = new_node
+
+        return head
+
+
+# @leet end

src/exercises/20.valid-parentheses.py

@@ -0,0 +1,57 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def isValid(self, s: str) -> bool:
+        if len(s) < 2:
+            return False
+        valid = {"]": "[", ")": "(", "}": "{"}
+        arr = []
+        for i in range(len(s)):
+            if s[i] in valid:
+                if len(arr) == 0:
+                    return False
+                if arr[len(arr) - 1] != valid[s[i]]:
+                    return False
+                arr.pop()
+            else:
+                arr.append(s[i])
+        return len(arr) == 0
+
+
+# @leet end
+

src/exercises/202.happy-number.py

@@ -0,0 +1,63 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet imports end
+
+
+# @leet start
+class Solution:
+    def isHappy(self, n: int) -> bool:
+        def getHappyNumber(num, memo):
+            if num not in memo:
+                memo.append(num)
+            else:
+                return False
+            count = 0
+            while num > 0:
+                d = num % 10
+                count += d**2
+                num //= 10
+
+            if count == 1:
+                return True
+            else:
+                return getHappyNumber(count, memo)
+
+        return getHappyNumber(n, [])
+
+
+# @leet end
+

src/exercises/2040.kth-smallest-product-of-two-sorted-arrays.py

@@ -0,0 +1,83 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def kthSmallestProduct(self, nums1: List[int], nums2: List[int], k: int) -> int:
+        low = -(10**10)
+        high = 10**10
+
+        def countLessEqual(p):
+            count = 0
+            for i in range(len(nums1)):
+                l, h = 0, len(nums2)
+                if nums1[i] == 0 and p >= 0:
+                    count += len(nums2)
+                elif nums1[i] > 0:
+                    while l < h:
+                        mid = (l + h) // 2
+                        x = nums1[i] * nums2[mid]
+                        if x <= p:
+                            l = mid + 1
+                        else:
+                            h = mid
+                    count += l
+                else:
+                    while l < h:
+                        mid = (l + h) // 2
+                        x = nums1[i] * nums2[mid]
+                        if x <= p:
+                            h = mid
+                        else:
+                            l = mid + 1
+                    count += len(nums2) - l
+
+                    
+
+            return count
+
+        while low < high:
+            mid = (low + high) // 2
+            count = countLessEqual(mid)
+            if count < k:
+                low = mid + 1
+            else:
+                high = mid
+
+        return low
+
+
+# @leet end

src/exercises/205.isomorphic-strings.py

@@ -0,0 +1,57 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet imports end
+
+
+# @leet start
+class Solution:
+    def isIsomorphic(self, s: str, t: str) -> bool:
+        if len(s) != len(t):
+            return False
+        d = {}
+        for i in range(len(s)):
+            if s[i] not in d:
+                if t[i] in d.values():
+                    return False
+                d[s[i]] = t[i]
+            else:
+                if s[i] in d and d[s[i]] != t[i]:
+                    return False
+
+        return True
+# @leet end
+

src/exercises/2053.kth-distinct-string-in-an-array.py

@@ -0,0 +1,60 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet imports end
+
+
+# @leet start
+class Solution:
+    def kthDistinct(self, arr: List[str], k: int) -> str:
+        disc = {}
+        banW = []
+        for w in arr:
+            if w not in disc and w not in banW:
+                disc[w] = 1
+            else:
+                if w not in banW:
+                    banW.append(w)
+                    del disc[w]
+
+        arr = list(disc.keys())
+        if k > len(arr): 
+            return ""
+        return arr[k - 1]
+
+
+# @leet end
+

src/exercises/206.reverse-linked-list.py

@@ -0,0 +1,59 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+# Definition for singly-linked list.
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        prev = None
+        curr = head
+
+        while curr:
+            next_node = curr.next
+            curr.next = prev
+            prev = curr
+            curr = next_node
+
+        return prev
+
+
+# @leet end

src/exercises/21.merge-two-sorted-lists.py

@@ -0,0 +1,45 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet start
+# 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]:
+        
+# @leet end

src/exercises/2116.check-if-a-parentheses-string-can-be-valid.py

@@ -0,0 +1,66 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet start
+class Solution:
+    def canBeValid(self, s: str, locked: str) -> bool:
+        var = ''
+        new_str = []
+        for i in s:
+            new_str.append(i)
+
+        for i in range(len(s)):
+            if i % 2 == 0:
+                var = '('
+                if var != s[i] and locked[i] == "0":
+                    new_str[i] = var
+            elif i % 2 != 0:
+                var = ')'
+                if var != s[i] and locked[i] == "0":
+                    new_str[i] = var
+
+        count_v = 0
+        count_x = 0
+        for i in new_str:
+            if i == ')':
+                count_x += 1
+            if i == '(':
+                count_v += 1
+
+        return count_v % 2 == 0 and count_x % 2 == 0
+
+
+        
+# @leet end

src/exercises/217.contains-duplicate.py

@@ -0,0 +1,46 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet start
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        seen = set()
+        for num in nums:
+            if num in seen:
+                return True
+            seen.add(num)
+        return False
+        
+# @leet end

src/exercises/219.contains-duplicate-ii.py

@@ -0,0 +1,55 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet imports end
+
+
+# @leet start
+class Solution:
+    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
+        if len(nums) <= 1:
+            return False
+        seen = set()
+        for i in range(len(nums)):
+            if nums[i] in seen:
+                return True
+            seen.add(nums[i])
+            if len(seen) > k:
+                seen.remove(nums[i - k])
+
+        return False
+# @leet end
+

src/exercises/22.generate-parentheses.py

@@ -0,0 +1,66 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def generateParenthesis(self, n: int) -> List[str]:
+        if n < 1:
+            return []
+        if n == 1:
+            return ["()"]
+
+        stack = []
+        res = []
+        def retrieveParenthesis(open, close):
+            if open == close == n:
+                res.append("".join(stack))
+                return
+            if open < n:
+                stack.append('(')
+                retrieveParenthesis(open + 1, close)
+                stack.pop()
+            if close < open:
+                stack.append(')')
+                retrieveParenthesis(open, close + 1)
+                stack.pop()
+
+        retrieveParenthesis(0, 0)
+
+        return res
+
+
+# @leet end
+

src/exercises/228.summary-ranges.py

@@ -0,0 +1,64 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+# @leet imports end
+
+# @leet start
+class Solution:
+    def summaryRanges(self, nums: List[int]) -> List[str]:
+        if len(nums) < 1:
+            return nums
+        if len(nums) == 1:
+            return [str(nums[-1])]
+        i, j = 0, 0
+        a = []
+        for h in range(1, len(nums), +1):
+            if nums[h - 1] + 1 == nums[h]: 
+                j += 1
+            else:
+                if i == j:
+                    a.append(str(nums[i]))
+                else:
+                    a.append("{}->{}".format(nums[i], nums[j]))
+                i = h
+                j = i
+
+        if i == len(nums) - 1:
+            a.append(str(nums[i]))
+        else: 
+            a.append("{}->{}".format(nums[i], nums[-1]))
+        return a
+        
+# @leet end

src/exercises/2294.partition-array-such-that-maximum-difference-is-k.py

@@ -0,0 +1,56 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def partitionArray(self, nums: List[int], k: int) -> int:
+        if k == 0:
+            return len(set(nums))
+        nums = sorted(list(set(nums)))
+        subs = 1
+        miv = float(inf)
+        for i in range(len(nums)):
+            miv = nums[i] if miv > nums[i] else miv
+            substraction = nums[i] - miv
+            if substraction > k:
+                subs += 1
+                miv = nums[i]
+
+        return subs
+
+
+# @leet end
+

src/exercises/238.product-of-array-except-self.py

@@ -0,0 +1,54 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        arr = [1 for _ in range(len(nums))]
+        left_product = 1
+        for i in range(len(nums)):
+            arr[i] = left_product
+            left_product *= nums[i]
+        right_product = 1
+        for i in range(len(nums) - 1, -1, -1):
+            arr[i] = right_product * arr[i]
+            right_product *= nums[i]
+
+        return arr
+
+
+# @leet end
+

src/exercises/242.valid-anagram.py

@@ -0,0 +1,42 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet start
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        return Counter(s) == Counter(t)
+        
+        
+# @leet end

src/exercises/243.shortest-word-distance.py

@@ -0,0 +1,64 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def shortestDistance(self, wordsDict: List[str], word1: str, word2: str) -> int:
+        word_indices = {}
+        for i, word in enumerate(wordsDict):
+            word_indices.setdefault(word, []).append(i)
+
+        pos1 = word_indices[word1]
+        pos2 = word_indices[word2]
+
+        i, j = 0, 0
+        min_distance = float("inf")
+
+        while i < len(pos1) and j < len(pos2):
+            index1 = pos1[i]
+            index2 = pos2[j]
+            min_distance = min(min_distance, abs(index1 - index2))
+
+            if index1 < index2:
+                i += 1
+            else:
+                j += 1
+
+        return min_distance
+
+
+# @leet end
+

src/exercises/244.shortest-word-distance-ii.py

@@ -0,0 +1,70 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet start
+class WordDistance:
+
+    wordsDistance = []
+    def __init__(self, wordsDict: List[str]):
+        self.wordsDistance = wordsDict
+        self.word_indices = {}
+        for i, word in enumerate(wordsDict):
+            self.word_indices.setdefault(word, []).append(i)
+
+    def shortest(self, word1: str, word2: str) -> int:
+        pos1 = self.word_indices[word1]
+        pos2 = self.word_indices[word2]
+        i, j = 0, 0
+        min_distance = float("inf")
+
+        while i < len(pos1) and j < len(pos2):
+            index1 = pos1[i]
+            index2 = pos2[j]
+            min_distance = min(min_distance, abs(index1 - index2))
+
+            if index1 < index2:
+                i += 1
+            else:
+                j += 1
+
+        return min_distance
+        
+        
+
+
+# Your WordDistance object will be instantiated and called as such:
+# obj = WordDistance(wordsDict)
+# param_1 = obj.shortest(word1,word2)
+# @leet end

src/exercises/245.shortest-word-distance-iii.py

@@ -0,0 +1,73 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def shortestWordDistance(self, wordsDict: List[str], word1: str, word2: str) -> int:
+        word_indices = {}
+        for i, word in enumerate(wordsDict):
+            word_indices.setdefault(word, []).append(i)
+
+        pos1 = word_indices[word1]
+        pos2 = word_indices[word2]
+
+        # Two-pointer traversal
+        i, j = 0, 0
+        min_distance = float("inf")
+
+        if word1 == word2:
+            for i in range(len(pos1)):
+                for j in range(len(pos2)):
+                    if i != j:
+                        min_distance = min(min_distance, abs(pos2[i] - pos2[j]))
+            return min_distance
+
+        while i < len(pos1) and j < len(pos2):
+            index1 = pos1[i]
+            index2 = pos2[j]
+            min_distance = min(min_distance, abs(index1 - index2))
+
+            # Move the pointer pointing to the smaller index
+            if index1 < index2:
+                i += 1
+            else:
+                j += 1
+
+        return min_distance
+
+
+# @leet end
+

src/exercises/246.strobogrammatic-number.py

@@ -0,0 +1,55 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def isStrobogrammatic(self, num: str) -> bool:
+        mapping = {"0": "0", "1": "1", "6": "9", "8": "8", "9": "6"}
+        left, right = 0, len(num) - 1
+
+        while left <= right:
+            if num[left] not in mapping or num[right] not in mapping:
+                return False
+            if mapping[num[left]] != num[right]:
+                return False
+            left += 1
+            right -= 1
+
+        return True
+
+
+# @leet end
+

src/exercises/248.strobogrammatic-number-iii.py

@@ -0,0 +1,65 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def strobogrammaticInRange(self, low: str, high: str) -> int:
+        def gen_str(l):
+            if l == 0:
+                return [""]
+            if l == 1:
+                return ["0", "1", "8"]
+            sub_ans = []
+            for n in gen_str(l - 2):
+                for pair in ("11", "88", "69", "96"):
+                    sub_ans.append(pair[0] + n + pair[1])
+                if l != num_l:
+                    sub_ans.append("0" + n + "0")
+            return sub_ans
+
+        min_l, max_l = len(low), len(high)
+        low, high = int(low), int(high)
+        count = 0
+
+        for num_l in range(min_l, max_l + 1):
+            for num_str in gen_str(num_l):
+                if low <= int(num_str) <= high:
+                    count += 1
+        return count
+
+
+# @leet end
+

src/exercises/2616.minimize-the-maximum-difference-of-pairs.py

@@ -0,0 +1,41 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet start
+class Solution:
+    def minimizeMax(self, nums: List[int], p: int) -> int:
+        nums.sort()
+        
+# @leet end

src/exercises/28.find-the-index-of-the-first-occurrence-in-a-string.py

@@ -0,0 +1,53 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet imports end
+
+
+# @leet start
+class Solution:
+    def strStr(self, haystack: str, needle: str) -> int:
+        for i in range(len(haystack)):
+            if i + len(needle) > len(haystack):
+                return -1
+            if haystack[i : i + len(needle)] == needle:
+                return i
+
+        return -1
+
+
+# @leet end;
+

src/exercises/290.word-pattern.py

@@ -0,0 +1,62 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet imports end
+
+
+# @leet start
+class Solution:
+    def wordPattern(self, pattern: str, s: str) -> bool:
+        w = {}
+        ss = s.split(" ")
+        if len(pattern) != len(ss):
+            return False
+
+        for i in range(len(ss)):
+            if pattern[i] not in w and ss[i] not in w.values():
+                w[pattern[i]] = ss[i]
+        for i in range(len(ss)):
+            if pattern[i] not in w:
+                return False
+            if ss[i] != w[pattern[i]]:
+                return False
+
+        return True
+
+
+
+# @leet end
+

src/exercises/2966.divide-array-into-arrays-with-max-difference.py

@@ -0,0 +1,40 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet start
+class Solution:
+    def divideArray(self, nums: List[int], k: int) -> List[List[int]]:
+        
+# @leet end

src/exercises/3.longest-substring-without-repeating-characters.py

@@ -0,0 +1,58 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        i, j = 0, 0
+        window = {}
+        max_char = 0
+        while j < len(s):
+            if s[j] not in window:
+                window[s[j]] = 1
+                max_char = (
+                    len(window.keys()) if max_char < len(window.keys()) else max_char
+                )
+                j += 1
+            elif s[j] in window:
+                del window[s[i]]
+                i += 1
+
+        return max_char
+
+
+# @leet end
+

src/exercises/3.longest-substring-without-repeating-characters.ts

@@ -0,0 +1,5 @@
+// @leet start
+function lengthOfLongestSubstring(s: string): number {
+    
+};
+// @leet end

src/exercises/3442.maximum-difference-between-even-and-odd-frequency-i.py

@@ -0,0 +1,54 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def maxDifference(self, s: str) -> int:
+        record = Counter(s)
+        max_odd = 0
+        min_even = float(inf)
+
+        for i in record.values():
+            if i % 2 == 0:
+                min_even = min(min_even, i)
+            elif i % 2 != 0:
+                max_odd = max(max_odd, i)
+
+        return max_odd - min_even
+
+
+# @leet end
+

src/exercises/3445.maximum-difference-between-even-and-odd-frequency-ii.py

@@ -0,0 +1,40 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet start
+class Solution:
+    def maxDifference(self, s: str, k: int) -> int:
+        
+# @leet end

src/exercises/35.search-insert-position.py

@@ -0,0 +1,55 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+# @leet imports end
+
+# @leet start
+class Solution:
+    def searchInsert(self, nums: List[int], target: int) -> int:
+        if nums[-1] < target:
+            return len(nums)
+        mn = 0 
+        mx = len(nums) - 1
+
+        while mn < mx:
+            mid = (mx + mn) // 2
+            if target > nums[mid]:
+                mn = mid + 1
+            else:
+                mx = mid
+            
+        return mn
+        
+# @leet end

src/exercises/36.valid-sudoku.py

@@ -0,0 +1,98 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def isValidSudoku(self, board: List[List[str]]) -> bool:
+        rows = [{} for _ in range(len(board))]
+        square = [{} for _ in range(len(board))]
+        for i in range(len(board)):
+            cols = {}
+            for j in range(len(board[i])):
+                val = board[i][j]
+                if val != ".":
+                    if val in cols:
+                        return False
+                    cols[val] = j
+                    if val in rows[j]:
+                        return False
+                    rows[j][val] = i
+                    if i < 3:
+                        if j < 3:
+                            if val in square[0]:
+                                return False
+                            square[0][val] = i
+                        elif j > 2 and j < 6:
+                            if val in square[1]:
+                                return False
+                            square[1][val] = i
+                        elif j > 5:
+                            if val in square[2]:
+                                return False
+                            square[2][val] = i
+                    elif i > 2 and i < 6:
+                        if j < 3:
+                            if val in square[3]:
+                                return False
+                            square[3][val] = i
+                        elif j > 2 and j < 6:
+                            if val in square[4]:
+                                return False
+                            square[4][val] = i
+                        elif j > 5:
+                            if val in square[5]:
+                                return False
+                            square[5][val] = i
+                    elif i > 5:
+                        if j < 3:
+                            if val in square[6]:
+                                return False
+                            square[6][val] = i
+                        elif j > 2 and j < 6:
+                            if val in square[7]:
+                                return False
+                            square[7][val] = i
+                        elif j > 5:
+                            if val in square[8]:
+                                return False
+                            square[8][val] = i
+
+
+        return True
+
+
+# @leet end
+

src/exercises/383.ransom-note.py

@@ -0,0 +1,66 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet imports end
+
+
+# @leet start
+class Solution:
+    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
+        def option1():
+            d = {}
+            for s in ransomNote:
+                if s not in d:
+                    d[s] = 1
+                else:
+                    d[s] += 1
+            for m in magazine:
+                if m in d:
+                    d[m] -= 1
+                    if d[m] == 0:
+                        del d[m]
+            return len(d.keys()) == 0
+
+        def option2():
+            r = Counter(ransomNote)
+            m = Counter(magazine)
+            return not(r - m)
+
+        return option2()
+
+
+# @leet end
+

src/exercises/392.is-subsequence.py

@@ -0,0 +1,54 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet imports end
+
+
+# @leet start
+class Solution:
+    def isSubsequence(self, s: str, t: str) -> bool:
+        i, j = 0, 0
+        while j < len(s):
+            if i >= len(t):
+                break
+            if t[i] == s[j]:
+                j += 1
+            i += 1
+
+        return j == len(s)
+
+
+# @leet end

src/exercises/4.median-of-two-sorted-arrays.py

@@ -0,0 +1,30 @@
+class Solution:
+    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
+        N1, N2 = nums1, nums2
+        lt = len(N1) + len(N2)
+        half = lt // 2
+
+        if len(N1) > len(N2):
+            N1, N2 = N2, N1
+
+        l = 0
+        h = len(N1) - 1
+        while True:
+            midA = (l + h) // 2
+            midB = half - midA - 2
+
+            aLeft = N1[midA] if midA >= 0 else float(-inf)
+            aRight = N1[midA + 1] if (midA + 1) < len(N1) else float(inf)
+
+            bLeft = N2[midB] if midB >= 0 else float(-inf)
+            bRight = N2[midB + 1] if (midB + 1) < len(N2) else float(inf)
+
+            if aLeft <= bRight and bLeft <= aRight:
+                if lt % 2 == 0:
+                    return (min(bRight, aRight) + max(bLeft, aLeft)) / 2
+                else:
+                    return min(bRight, aRight)
+            if aLeft > bRight:
+                h = midA - 1
+            else:
+                l = midA + 1

src/exercises/42.trapping-rain-water.py

@@ -0,0 +1,60 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def trap(self, height: List[int]) -> int:
+        i, j = 0, len(height) - 1
+        c, m_l, m_r = 0, 0, 0
+        while i < j:
+            if height[i] < height[j]:
+                if m_l < height[i]:
+                    m_l = height[i]
+                if (m_l - height[i]) > 0:
+                    c += m_l - height[i]
+                i += 1
+            else:
+                if m_r < height[j]:
+                    m_r = height[j]
+                if (m_r - height[j]) > 0:
+                    c += m_r - height[j]
+                j -= 1
+
+        return c
+
+
+# @leet end
+

src/exercises/45.jump-game-ii.py

@@ -0,0 +1,42 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+# @leet imports end
+
+# @leet start
+class Solution:
+    def jump(self, nums: List[int]) -> int:
+        
+# @leet end

src/exercises/5.longest-palindromic-substring.py

@@ -0,0 +1,66 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet imports end
+
+
+# @leet start
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+        if len(s) <= 1:
+            return s
+        max_string = float(-inf)
+        ans = ""
+        i = 0
+
+        def checker(l, r, a, mx):
+            while l >= 0 and r < len(s) and s[l] == s[r]:
+                if (r - l + 1) > max_string:
+                    a = s[l : r + 1]
+                    mx = r - l + 1
+                l -= 1
+                r += 1
+            return a, mx
+
+        for i in range(len(s)):
+            ans, max_string = checker(i, i, ans, max_string)
+            ans, max_string = checker(i, i + 1, ans, max_string)
+
+        return ans
+
+
+# @leet end
+

src/exercises/50.powx-n.py

@@ -0,0 +1,53 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+# @leet imports end
+
+# @leet start
+class Solution:
+    def myPow(self, x: float, n: int) -> float:
+        if n == 0:
+            return 1
+        def getP(xx, nn):
+            if nn == 1: return xx
+            h = getP(xx, nn // 2)
+            if nn % 2 == 0:
+                return h * h
+            else:
+                return xx * h * h
+        if n < 0:
+            return 1 / getP(x, abs(n))
+        return getP(x, n)
+# @leet end

src/exercises/55.jump-game.py

@@ -0,0 +1,53 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet imports end
+
+
+# @leet start
+class Solution:
+    def canJump(self, nums: List[int]) -> bool:
+        f = 0
+        for i in range(len(nums)):
+            if f < i:
+                return False
+            f = nums[i] + i if nums[i] + i > f else f
+
+        return True
+
+
+# @leet end
+

src/exercises/66.plus-one.py

@@ -0,0 +1,64 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet imports end
+
+
+# @leet start
+class Solution:
+    def plusOne(self, digits: List[int]) -> List[int]:
+        def sumDigits(arr, con, i):
+            if i < 0:
+                arr.insert(0, con)
+                return arr
+            if con != None:
+                n = arr[i] + con
+            else:
+                n = arr[i] + 1
+            if n < 10:
+                arr[i] = n
+            else:
+                ci = n % 10
+                con = n // 10
+                arr[i] = ci
+                return sumDigits(arr, con, i - 1)
+            return arr
+
+        return sumDigits(digits, None, len(digits) - 1)
+
+
+# @leet end
+

src/exercises/69.sqrtx.py

@@ -0,0 +1,58 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet imports end
+
+
+# @leet start
+class Solution:
+    def mySqrt(self, x: int) -> int:
+        if x == 1:
+            return x
+        lw = 1
+        lm = x
+        while lw < lm:
+            mid = (lw + lm) // 2
+            s = mid**2
+            if s <= x:
+                lw = mid + 1
+            else:
+                lm = mid
+        return lw - 1
+
+
+# @leet end
+

src/exercises/704.binary-search.py

@@ -0,0 +1,59 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet start
+class Solution:
+    def search(self, nums: List[int], target: int) -> int:
+        
+        def bin_search(low, high):
+            if low > high:
+                return -1
+            mid = (high + low) // 2
+            if nums[low] == target:
+                return low
+            if nums[high] == target:
+                return high
+            if nums[mid] == target:
+                return mid
+            if nums[mid] < target:
+                return bin_search(mid + 1, high)
+            if nums[mid] > target:
+                return bin_search(low, mid - 1)
+
+        return bin_search(0, len(nums) - 1)
+            
+
+        
+# @leet end

src/exercises/74.search-a-2d-matrix.py

@@ -0,0 +1,79 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
+        def row_search(low, high):
+            if low > high:
+                return -1
+            if matrix[low][0] <= target and target <= matrix[0][len(matrix[low]) - 1]:
+                return low
+            if matrix[high][0] <= target and target <= matrix[0][len(matrix[high]) - 1]:
+                return high
+
+            mid = (low + high) // 2
+            if matrix[mid][0] <= target and target <= matrix[mid][len(matrix[mid]) - 1]:
+                return mid
+            if matrix[mid][0] < target:
+                return row_search(mid + 1, high)
+            if matrix[mid][0] > target:
+                return row_search(low, mid - 1)
+
+        row = row_search(0, len(matrix) - 1)
+        nums = matrix[row]
+
+        def bin_search(low, high):
+            if low > high:
+                return -1
+            mid = (high + low) // 2
+            if nums[low] == target:
+                return low
+            if nums[high] == target:
+                return high
+            if nums[mid] == target:
+                return mid
+            if nums[mid] < target:
+                return bin_search(mid + 1, high)
+            if nums[mid] > target:
+                return bin_search(low, mid - 1)
+
+        isValid = bin_search(0, len(nums) - 1)
+        return isValid != -1
+
+
+# @leet end
+

src/exercises/80.remove-duplicates-from-sorted-array-ii.py

@@ -0,0 +1,56 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+# @leet imports end
+
+# @leet start
+class Solution:
+    def removeDuplicates(self, nums: List[int]) -> int:
+        if not nums:
+            return 0
+        if len(nums) <= 2:
+            return len(nums)
+        k = 2
+        for i in range(2, len(nums)):
+            if nums[i] != nums[k - 1] or nums[i] != nums[k - 2]:
+                nums[k] = nums[i]
+                k += 1
+        print(nums)
+
+        return k
+
+
+            
+# @leet end

src/exercises/875.koko-eating-bananas.py

@@ -0,0 +1,57 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def minEatingSpeed(self, piles: List[int], h: int) -> int:
+        def bs(val, low, high, len):
+            if low > high:
+                return val
+            mid = (low + high) // 2
+            sum_v = 0
+            for i in range(len):
+                sum_v += (piles[i]  + mid - 1) // mid
+            if sum_v <= h:
+                min_val = min(val, mid)
+                return bs(min_val, low, mid - 1, len)
+            else:
+                return bs(val, mid + 1, high, len)
+
+        return bs(float(inf), 1, max(piles), len(piles))
+
+
+# @leet end
+

src/exercises/88.merge-sorted-array.py

@@ -0,0 +1,48 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
+        k = 0
+        for i in range(m, len(nums1)):
+            nums1[i] = nums2[k]
+            k += 1
+        nums1 = nums1.sort()
+        return nums1
+        
+# @leet end
+

src/exercises/89.gray-code.py

@@ -0,0 +1,45 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def grayCode(self, n: int) -> List[int]:
+        return [i ^ (i >> 1) for i in range(1 << n)]
+        
+
+
+# @leet end
+

src/exercises/9.palindrome-number.py

@@ -0,0 +1,51 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet start
+class Solution:
+    def isPalindrome(self, x: int) -> bool:
+        i = 0
+        n = str(x)
+        j = len(n) - 1
+        while i < j:
+            if n[i] == n[j]:
+                i += 1
+                j -= 1
+            else:
+                return False
+
+        return True
+
+# @leet end

src/exercises/90.subsets-ii.py

@@ -0,0 +1,60 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
+        res = []
+
+        nums.sort()
+
+        def backtrack(start, path):
+            res.append(path[:])
+
+            for i in range(start, len(nums)):
+                if i > start and nums[i] == nums[i - 1]:
+                    continue
+
+                path.append(nums[i])
+                backtrack(i + 1, path)
+                path.pop()
+
+        backtrack(0, [])
+        return res
+
+
+# @leet end
+

src/exercises/91.decode-ways.py

@@ -0,0 +1,57 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+
+# @leet start
+class Solution:
+    @lru_cache(maxsize=None)
+    def getWordsCount(self, i, s) -> int:
+        if i == len(s):
+            return 1
+        if s[i] == "0":
+            return 0
+        if i == len(s) - 1:
+            return 1
+        answer = self.getWordsCount(i + 1, s)
+        if int(s[i : i + 2]) < 27:
+            answer += self.getWordsCount(i + 2, s)
+        return answer
+
+    def numDecodings(self, s: str) -> int:
+        return self.getWordsCount(0, s)
+
+
+# @leet end
+

src/exercises/92.reverse-linked-list-ii.py

@@ -0,0 +1,45 @@
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+
+# @leet start
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:
+        
+# @leet end

src/exercises/990.satisfiability-of-equality-equations.py

@@ -0,0 +1,42 @@
+# @leet imports start
+from string import *
+from re import *
+from datetime import *
+from collections import *
+from heapq import *
+from bisect import *
+from copy import *
+from math import *
+from random import *
+from statistics import *
+from itertools import *
+from functools import *
+from operator import *
+from io import *
+from sys import *
+from json import *
+from builtins import *
+import string
+import re
+import datetime
+import collections
+import heapq
+import bisect
+import copy
+import math
+import random
+import statistics
+import itertools
+import functools
+import operator
+import io
+import sys
+import json
+from typing import *
+# @leet imports end
+
+# @leet start
+class Solution:
+    def equationsPossible(self, equations: List[str]) -> bool:
+        
+# @leet end