add

Author: idf

1001 Grid Illumination.py

@@ -0,0 +1,4 @@
+#!/usr/bin/python3
+"""
+
+"""

1003 Check If Word Is Valid After Substitutions.py

@@ -0,0 +1,77 @@
+#!/usr/bin/python3
+"""
+Given a string s, determine if it is valid.
+
+A string s is valid if, starting with an empty string t = "", you can transform t into s after performing the following operation any number of times:
+
+Insert string "abc" into any position in t. More formally, t becomes tleft + "abc" + tright, where t == tleft + tright. Note that tleft and tright may be empty.
+Return true if s is a valid string, otherwise, return false.
+
+ 
+
+Example 1:
+
+Input: s = "aabcbc"
+Output: true
+Explanation:
+"" -> "abc" -> "aabcbc"
+Thus, "aabcbc" is valid.
+Example 2:
+
+Input: s = "abcabcababcc"
+Output: true
+Explanation:
+"" -> "abc" -> "abcabc" -> "abcabcabc" -> "abcabcababcc"
+Thus, "abcabcababcc" is valid.
+Example 3:
+
+Input: s = "abccba"
+Output: false
+Explanation: It is impossible to get "abccba" using the operation.
+ 
+
+Constraints:
+
+1 <= s.length <= 2 * 104
+s consists of letters 'a', 'b', and 'c'
+"""
+
+from collections import defaultdict
+
+class Solution:
+    def isValid_naive(self, s: str) -> bool:
+        """
+        similar to valid parenthesis of ()
+        cnt[a] >= cnt[b] >= cnt[c]
+        in the end, cnt[a] == cnt[b] == cnt[c]
+        but aaabbbccc is invalid 
+
+        remove "abc", there another "abc" in the string. O(N^2)
+        """
+        if len(s) == 0:
+            return True 
+        
+        for i in range(len(s) - 2):
+            if s[i:i+3] == "abc":
+                return self.isValid(s[:i] + s[i+3:])
+        
+        return False
+
+    def isValid(self, s: str) -> bool:
+        """
+        when c, we there must be a and b immediately before
+        using stk
+        """
+        stk = []
+        for e in s:
+            if e in ("a", "b"):
+                stk.append(e)
+            else:  # "c"
+                if len(stk) < 2:
+                    return False 
+                if stk.pop() != "b":
+                    return False
+                if stk.pop() != "a":
+                    return False
+            
+        return len(stk) == 0

1006 Clumsy Factorial.py

@@ -0,0 +1,67 @@
+#!/usr/bin/python3
+"""
+The factorial of a positive integer n is the product of all positive integers less than or equal to n.
+
+For example, factorial(10) = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1.
+We make a clumsy factorial using the integers in decreasing order by swapping out the multiply operations for a fixed rotation of operations with multiply '*', divide '/', add '+', and subtract '-' in this order.
+
+For example, clumsy(10) = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1.
+However, these operations are still applied using the usual order of operations of arithmetic. We do all multiplication and division steps before any addition or subtraction steps, and multiplication and division steps are processed left to right.
+
+Additionally, the division that we use is floor division such that 10 * 9 / 8 = 90 / 8 = 11.
+
+Given an integer n, return the clumsy factorial of n.
+
+ 
+
+Example 1:
+
+Input: n = 4
+Output: 7
+Explanation: 7 = 4 * 3 / 2 + 1
+Example 2:
+
+Input: n = 10
+Output: 12
+Explanation: 12 = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1
+ 
+
+Constraints:
+
+1 <= n <= 104
+"""
+
+class Solution:
+    def clumsy(self, n: int) -> int:
+        """
+        * / + -
+        + is applied,
+        - the next set of * /
+        """
+        accu = 0
+        for i in range(min(4, n)):
+            num = n - i
+            if i % 4 == 0:
+                accu += num
+            elif i % 4 == 1:
+                accu *= num
+            elif i % 4 == 2:
+                accu //= num
+            else:
+                accu += num
+        
+        cur = 0
+        for i in range(4, n):
+            num = n - i
+            if i % 4 == 0:
+                cur += num
+            elif i % 4 == 1:
+                cur *= num
+            elif i % 4 == 2:
+                cur //= num
+            else:
+                accu += num
+                accu -= cur
+                cur = 0
+        
+        return accu - cur  # remaining cur

1007 Minimum Domino Rotations For Equal Row.py

@@ -0,0 +1,59 @@
+#!/usr/bin/python3
+"""
+In a row of dominoes, tops[i] and bottoms[i] represent the top and bottom halves of the ith domino. (A domino is a tile with two numbers from 1 to 6 - one on each half of the tile.)
+
+We may rotate the ith domino, so that tops[i] and bottoms[i] swap values.
+
+Return the minimum number of rotations so that all the values in tops are the same, or all the values in bottoms are the same.
+
+If it cannot be done, return -1.
+
+
+Example 1:
+
+
+Input: tops = [2,1,2,4,2,2], bottoms = [5,2,6,2,3,2]
+Output: 2
+Explanation: 
+The first figure represents the dominoes as given by tops and bottoms: before we do any rotations.
+If we rotate the second and fourth dominoes, we can make every value in the top row equal to 2, as indicated by the second figure.
+Example 2:
+
+Input: tops = [3,5,1,2,3], bottoms = [3,6,3,3,4]
+Output: -1
+Explanation: 
+In this case, it is not possible to rotate the dominoes to make one row of values equal.
+ 
+
+Constraints:
+
+2 <= tops.length <= 2 * 104
+bottoms.length == tops.length
+1 <= tops[i], bottoms[i] <= 6
+"""
+class Solution:
+    def minDominoRotations(self, tops: List[int], bottoms: List[int]) -> int:
+        """
+        Mainly focus on making tops the same
+        bottoms check can be done by swapping the params 
+
+        find target first and then swap
+        """
+        return min(self.find_min(tops, bottoms), self.find_min(bottoms, tops))
+    
+    def find_min(self, tops, bottoms):
+        targets = set([tops[0], bottoms[0]])
+        N = len(tops)
+        for i in range(1, N):
+            targets &= set([tops[i], bottoms[i]])
+
+        if len(targets) == 0:
+            return -1
+        
+        target = targets.pop()
+        swap = 0
+        for i in range(N):
+            if target != tops[i]:
+                swap += 1
+
+        return swap

1015 Smallest Integer Divisible by K.py

@@ -0,0 +1,57 @@
+#!/usr/bin/python3
+"""
+Given a positive integer k, you need to find the length of the smallest positive integer n such that n is divisible by k, and n only contains the digit 1.
+
+Return the length of n. If there is no such n, return -1.
+
+Note: n may not fit in a 64-bit signed integer.
+
+ 
+
+Example 1:
+
+Input: k = 1
+Output: 1
+Explanation: The smallest answer is n = 1, which has length 1.
+Example 2:
+
+Input: k = 2
+Output: -1
+Explanation: There is no such positive integer n divisible by 2.
+Example 3:
+
+Input: k = 3
+Output: 3
+Explanation: The smallest answer is n = 111, which has length 3.
+ 
+
+Constraints:
+
+1 <= k <= 10^5
+"""
+from collections import defaultdict
+
+
+class Solution:
+    def smallestRepunitDivByK(self, k: int) -> int:
+        """
+        1 % k = 1 
+        11 % k = prev * 10 + 1 % k
+        111 % k = prev * 10 + 1 % k
+        """
+        if k % 2 == 0 or k % 5 == 0:
+            return -1
+
+        hit = defaultdict(bool)
+        l = 1
+        cur = 1
+        remainder = 1 % k
+        while True:
+            if hit[remainder]:
+                return -1
+            if remainder == 0:
+                return l
+            
+            hit[remainder] = True
+            remainder = (remainder * 10 + 1) % k
+            l += 1            

1016 Binary String With Substrings Representing 1 To N.py

@@ -0,0 +1,48 @@
+#!/usr/bin/python3
+"""
+Given a binary string s and a positive integer n, return true if the binary representation of all the integers in the range [1, n] are substrings of s, or false otherwise.
+
+A substring is a contiguous sequence of characters within a string.
+
+Example 1:
+
+Input: s = "0110", n = 3
+Output: true
+Example 2:
+
+Input: s = "0110", n = 4
+Output: false
+ 
+
+Constraints:
+
+1 <= s.length <= 1000
+s[i] is either '0' or '1'.
+1 <= n <= 10^9
+"""
+
+class Solution:
+    def queryString(self, s: str, n: int) -> bool:
+        """
+        Naive solution: KMP string matching from 1 to N, O(N * (m + n)).
+        Python `in` is enough
+
+        Construct numbers from the string s itself
+        Scan the s from left to right 
+        """
+        numbers = set()
+        for i in range(len(s)):
+            cur = 0
+            sig = 1
+            for j in range(i, len(s)):
+                if s[~j] == "1":
+                    cur += sig
+                if cur > n:
+                    break
+
+                sig <<= 1
+                
+                if cur != 0:
+                    numbers.add(cur)
+        
+        return len(numbers) == n