add more problems

Author: LEUNGUU

easy/10.regular_expression_matching.py

@@ -0,0 +1,96 @@
+# Regular Expression Matching
+#
+# [Hard] [AC:27.0% 463.7K of 1.7M] [filetype:python3]
+#
+# Given an input string (s) and a pattern (p), implement regular expression matching with support for '.' and '*'.
+#
+# '.' Matches any single character.
+#
+# '*' Matches zero or more of the preceding element.
+#
+# The matching should cover the entire input string (not partial).
+#
+# Note:
+#
+# s could be empty and contains only lowercase letters a-z.
+#
+# p could be empty and contains only lowercase letters a-z, and characters like . or *.
+#
+# Example 1:
+#
+# Input:
+#
+# s = "aa"
+#
+# p = "a"
+#
+# Output: false
+#
+# Explanation: "a" does not match the entire string "aa".
+#
+# Example 2:
+#
+# Input:
+#
+# s = "aa"
+#
+# p = "a*"
+#
+# Output: true
+#
+# Explanation: '*' means zero or more of the preceding element, 'a'. Therefore, by repeating 'a' once, it becomes "aa".
+#
+# Example 3:
+#
+# Input:
+#
+# s = "ab"
+#
+# p = ".*"
+#
+# Output: true
+#
+# Explanation: ".*" means "zero or more (*) of any character (.)".
+#
+# Example 4:
+#
+# Input:
+#
+# s = "aab"
+#
+# p = "c*a*b"
+#
+# Output: true
+#
+# Explanation: c can be repeated 0 times, a can be repeated 1 time. Therefore, it matches "aab".
+#
+# Example 5:
+#
+# Input:
+#
+# s = "mississippi"
+#
+# p = "mis*is*p*."
+#
+# Output: false
+#
+# [End of Description]:
+class Solution:
+    def isMatch(self, s: str, p: str) -> bool:
+        memo = dict()
+
+        def dp(i, j):
+            if (i, j) in memo:
+                return memo[(i, j)]
+            if j == len(p):
+                return i == len(s)
+            first = i < len(s) and p[j] in {s[i], "."}
+
+            if j <= len(p) - 2 and p[j + 1] == "*":
+                ans = dp(i, j + 2) or first and dp(i + 1, j)
+            else:
+                ans = first and dp(i + 1, j + 1)
+            memo[(i, j)] = ans
+            return ans
+
+        return dp(0, 0)

easy/312.burst_balloons.py

@@ -0,0 +1,53 @@
+# Burst Balloons
+#
+# [Hard] [AC:52.2% 103.9K of 198.9K] [filetype:python3]
+#
+# Given n balloons, indexed from 0 to n-1. Each balloon is painted with a number on it represented by array nums. You
+# are asked to burst all the balloons. If the you burst balloon i you will get nums[left] * nums[i] * nums[right] coins.
+# Here left and right are adjacent indices of i. After the burst, the left and right then becomes adjacent.
+#
+# Find the maximum coins you can collect by bursting the balloons wisely.
+#
+# Note:
+#
+# You may imagine nums[-1] = nums[n] = 1. They are not real therefore you can not burst them.
+#
+# 0 ≤ n ≤ 500, 0 ≤ nums[i] ≤ 100
+#
+# Example:
+#
+# Input: [3,1,5,8]
+#
+# Output: 167
+#
+# Explanation: nums = [3,1,5,8] --> [3,5,8] -->   [3,8]   -->  [8]  --> []
+#
+#              coins =  3*1*5      +  3*5*8    +  1*3*8      + 1*8*1   = 167
+#
+# [End of Description]:
+class Solution:
+    def maxCoins(self, nums: List[int]) -> int:
+        # we create array first
+        sz = len(nums)
+        # add two virtual balloons
+        points = [None] * (sz + 2)
+        points[0] = points[sz + 1] = 1
+        for i in range(1, sz + 1):
+            points[i] = nums[i - 1]
+
+        # initialize dp array
+        dp = []
+        for _ in range(sz + 2):
+            inner = []
+            for _ in range(sz + 2):
+                inner.append(0)
+            dp.append(inner)
+        # according to dp table
+        for i in range(sz, -1, -1):
+            for j in range(i + 1, sz + 2):
+                for k in range(i + 1, j):
+                    dp[i][j] = max(
+                        dp[i][j],
+                        dp[i][k] + dp[k][j] + points[i] * points[j] * points[k],
+                    )
+        return dp[0][sz + 1]

easy/319.bulb_switcher.py

@@ -0,0 +1,33 @@
+# Bulb Switcher
+#
+# [Medium] [AC:45.3% 82.8K of 182.8K] [filetype:python3]
+#
+# There are n bulbs that are initially off. You first turn on all the bulbs. Then, you turn off every second bulb. On
+# the third round, you toggle every third bulb (turning on if it's off or turning off if it's on). For the i-th round,
+# you toggle every i bulb. For the n-th round, you only toggle the last bulb. Find how many bulbs are on after n rounds.
+#
+# Example:
+#
+# Input: 3
+#
+# Output: 1
+#
+# Explanation:
+#
+# At first, the three bulbs are [off, off, off].
+#
+# After first round, the three bulbs are [on, on, on].
+#
+# After second round, the three bulbs are [on, off, on].
+#
+# After third round, the three bulbs are [on, off, off].
+#
+# So you should return 1, because there is only one bulb is on.
+#
+# [End of Description]:
+import math
+
+
+class Solution:
+    def bulbSwitch(self, n: int) -> int:
+        return int(math.sqrt(n))

easy/651.4_keys_keyboard.py

@@ -0,0 +1,61 @@
+# 4 Keys Keyboard
+#
+# [Medium] [AC:52.7% 16.7K of 31.7K] [filetype:python3]
+#
+# Imagine you have a special keyboard with the following keys:
+#
+# Key 1: (A):  Print one 'A' on screen.
+#
+# Key 2: (Ctrl-A): Select the whole screen.
+#
+# Key 3: (Ctrl-C): Copy selection to buffer.
+#
+# Key 4: (Ctrl-V): Print buffer on screen appending it after what has already been printed.
+#
+# Now, you can only press the keyboard for N times (with the above four keys), find out the maximum numbers of 'A' you
+# can print on screen.
+#
+# Example 1:
+#
+# Input: N = 3
+#
+# Output: 3
+#
+# Explanation:
+#
+# We can at most get 3 A's on screen by pressing following key sequence:
+#
+# A, A, A
+#
+# Example 2:
+#
+# Input: N = 7
+#
+# Output: 9
+#
+# Explanation:
+#
+# We can at most get 9 A's on screen by pressing following key sequence:
+#
+# A, A, A, Ctrl A, Ctrl C, Ctrl V, Ctrl V
+#
+# Note:
+#
+# 1 <= N <= 50
+#
+# Answers will be in the range of 32-bit signed integer.
+#
+# [End of Description]:
+class Solution:
+    def maxA(self, N: int) -> int:
+        dp = [None] * (N + 1)
+        dp[0] = 0
+        for i in range(1, N + 1):
+            # press A
+            dp[i] = dp[i - 1] + 1
+            for j in range(2, i):
+                # C-A & C-C dp[j-2], C-V (i - j) times
+                # total: dp[j - 2] * (i - j + 1) A
+                dp[i] = max(dp[i], dp[j - 2] * (i - j + 1))
+        # After N times
+        return dp[N]

easy/72.edit_distance.py

@@ -0,0 +1,69 @@
+# Edit Distance
+#
+# [Hard] [AC:45.4% 302.7K of 666.6K] [filetype:python3]
+#
+# Given two words word1 and word2, find the minimum number of operations required to convert word1 to word2.
+#
+# You have the following 3 operations permitted on a word:
+#
+# Insert a character
+#
+# Delete a character
+#
+# Replace a character
+#
+# Example 1:
+#
+# Input: word1 = "horse", word2 = "ros"
+#
+# Output: 3
+#
+# Explanation:
+#
+# horse -> rorse (replace 'h' with 'r')
+#
+# rorse -> rose (remove 'r')
+#
+# rose -> ros (remove 'e')
+#
+# Example 2:
+#
+# Input: word1 = "intention", word2 = "execution"
+#
+# Output: 5
+#
+# Explanation:
+#
+# intention -> inention (remove 't')
+#
+# inention -> enention (replace 'i' with 'e')
+#
+# enention -> exention (replace 'n' with 'x')
+#
+# exention -> exection (replace 'n' with 'c')
+#
+# exection -> execution (insert 'u')
+#
+# [End of Description]:
+class Solution:
+    def minDistance(self, word1: str, word2: str) -> int:
+        memo = dict()
+
+        def dp(i, j):
+            # base case
+            if i == -1:
+                return j + 1
+            if j == -1:
+                return i + 1
+
+            if (i, j) in memo:
+                return memo[(i, j)]
+            if word1[i] == word2[j]:
+                memo[(i, j)] = dp(i - 1, j - 1)
+            else:
+                memo[(i, j)] = min(
+                    dp(i - 1, j) + 1, dp(i - 1, j - 1) + 1, dp(i, j - 1) + 1
+                )
+            return memo[(i, j)]
+
+        return dp(len(word1) - 1, len(word2) - 1)

easy/877.stone_game.py

@@ -0,0 +1,47 @@
+# Stone Game
+#
+# [Medium] [AC:65.7% 66.4K of 101.1K] [filetype:python3]
+#
+# Alex and Lee play a game with piles of stones.  There are an even number of piles arranged in a row, and each pile has
+# a positive integer number of stones piles[i].
+#
+# The objective of the game is to end with the most stones.  The total number of stones is odd, so there are no ties.
+#
+# Alex and Lee take turns, with Alex starting first.  Each turn, a player takes the entire pile of stones from either
+# the beginning or the end of the row.  This continues until there are no more piles left, at which point the person
+# with the most stones wins.
+#
+# Assuming Alex and Lee play optimally, return True if and only if Alex wins the game.
+#
+# Example 1:
+#
+# Input: piles = [5,3,4,5]
+#
+# Output: true
+#
+# Explanation:
+#
+# Alex starts first, and can only take the first 5 or the last 5.
+#
+# Say he takes the first 5, so that the row becomes [3, 4, 5].
+#
+# If Lee takes 3, then the board is [4, 5], and Alex takes 5 to win with 10 points.
+#
+# If Lee takes the last 5, then the board is [3, 4], and Alex takes 4 to win with 9 points.
+#
+# This demonstrated that taking the first 5 was a winning move for Alex, so we return true.
+#
+# Constraints:
+#
+# 2 <= piles.length <= 500
+#
+# piles.length is even.
+#
+# 1 <= piles[i] <= 500
+#
+# sum(piles) is odd.
+#
+# [End of Description]:
+class Solution:
+    def stoneGame(self, piles: List[int]) -> bool:
+        return True