added Parsing a boolean expression

Author: dev-sire

Leetcode Daily/Hard/ParsingABooleanExpression.py

@@ -0,0 +1,36 @@
+import functools
+import operator
+
+class Solution:
+  def parseBoolExpr(self, expression: str) -> bool:
+    def dfs(s: int, e: int) -> list[str]:
+      if s == e:
+        return True if expression[s] == 't' else False
+
+      exps = []
+      layer = 0
+
+      for i in range(s, e + 1):
+        c = expression[i]
+        if layer == 0 and c in '!&|':
+          op = c
+        elif c == '(':
+          layer += 1
+          if layer == 1:
+            left = i + 1
+        elif c == ')':
+          layer -= 1
+          if layer == 0:
+            exps.append(dfs(left, i - 1))
+        elif c == ',' and layer == 1:
+          exps.append(dfs(left, i - 1))
+          left = i + 1
+
+      if op == '|':
+        return functools.reduce(operator.or_, exps)
+      if op == '&':
+        return functools.reduce(operator.and_, exps)
+      if op == '!':
+        return not exps[0]
+
+    return dfs(0, len(expression) - 1)

Leetcode Daily/Medium/CountNumOfMaxBitwise.py

@@ -0,0 +1,20 @@
+import functools
+import operator
+
+class Solution:
+  def countMaxOrSubsets(self, nums: list[int]) -> int:
+    ors = functools.reduce(operator.or_, nums)
+    ans = 0
+
+    def dfs(i: int, path: int) -> None:
+        nonlocal ans
+        if i == len(nums):
+            if path == ors:
+                ans += 1
+                return
+        dfs(i + 1, path)
+        dfs(i + 1, path | nums[i])
+
+    dfs(0, 0)
+    
+    return ans

Leetcode Daily/Medium/FindKthBitInNthBinaryString.py

@@ -0,0 +1,11 @@
+class Solution:
+    def findKthBit(self, n: int, k: int) -> str:
+        if n == 1:
+            return '0'
+        midIndex = pow(2, n - 1)  # 1-indexed
+        if k == midIndex:
+            return '1'
+        if k < midIndex:
+            return self.findKthBit(n - 1, k)
+            
+        return '1' if self.findKthBit(n - 1, midIndex * 2 - k) == '0' else '0'

Leetcode Daily/Medium/LongestHappyString.py

@@ -0,0 +1,31 @@
+from heapq import heappop, heappush
+
+class Solution:
+    def longestDiverseString(self, a: int, b: int, c: int) -> str:
+        h = []
+        if a > 0:
+            heappush(h, [-a, 'a'])
+        if b > 0:
+            heappush(h, [-b, 'b'])
+        if c > 0:
+            heappush(h, [-c, 'c'])
+
+        ans = []
+        while len(h) > 0:
+            cur = heappop(h)
+            if len(ans) >= 2 and ans[-1] == cur[1] and ans[-2] == cur[1]:
+                if len(h) == 0:
+                    break
+                nxt = heappop(h)
+                ans.append(nxt[1])
+                if -nxt[0] > 1:
+                    nxt[0] += 1
+                    heappush(h, nxt)
+                heappush(h, cur)
+            else:
+                ans.append(cur[1])
+                if -cur[0] > 1:
+                    cur[0] += 1
+                    heappush(h, cur)
+
+        return ''.join(ans)       

Leetcode Daily/Medium/MaxScoreAfterKOperations.py

@@ -0,0 +1,15 @@
+from ast import List
+import heapq
+
+class Solution:
+    def maxKelements(self, nums: List[int], k: int) -> int:
+        ans = 0
+        maxHeap = [-num for num in nums]
+        heapq.heapify(maxHeap)
+
+        for _ in range(k):
+            num = -heapq.heappop(maxHeap)
+            ans += num
+            heapq.heappush(maxHeap, -math.ceil(num / 3))
+
+        return ans

Leetcode Daily/Medium/MaximumSwaps.py

@@ -0,0 +1,16 @@
+import string
+
+class Solution:
+  def maximumSwap(self, num: int) -> int:
+    s = list(str(num))
+    dict = {c: i for i, c in enumerate(s)}
+
+    for i, c in enumerate(s):
+      for digit in reversed(string.digits):
+        if digit <= c:
+          break
+        if digit in dict and dict[digit] > i:
+          s[i], s[dict[digit]] = digit, s[i]
+          return int(''.join(s))
+
+    return num

Leetcode Daily/Medium/SeparateBlackAndWhiteBalls.py

@@ -0,0 +1,12 @@
+class Solution:  
+  def minimumSteps(self, s: str) -> int:
+    ans = 0
+    ones = 0
+
+    for c in s:
+      if c == '1':
+        ones += 1
+      else:  # Move 1s to the front of the current '0'.
+        ans += ones
+
+    return ans