ShwStone/humaneval-leetcode huggingface dataset:
def numTilePossibilities(tiles: str) -> int:
    """
    You have n  tiles, where each tile has one letter tiles[i] printed on it.
    Return the number of possible non-empty sequences of letters you can make using the letters printed on those tiles.
    
    Example 1:
    
    >>> numTilePossibilities(tiles = "AAB")
    >>> 8
    Explanation: The possible sequences are "A", "B", "AA", "AB", "BA", "AAB", "ABA", "BAA".
    
    Example 2:
    
    >>> numTilePossibilities(tiles = "AAABBC")
    >>> 188
    
    Example 3:
    
    >>> numTilePossibilities(tiles = "V")
    >>> 1
    """
# class TreeNode:
#     def __init__(val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def sufficientSubset(root: Optional[TreeNode], limit: int) -> Optional[TreeNode]:
    """
    Given the root of a binary tree and an integer limit, delete all insufficient nodes in the tree simultaneously, and return the root of the resulting binary tree.
    A node is insufficient if every root to leaf path intersecting this node has a sum strictly less than limit.
    A leaf is a node with no children.
    
    Example 1:
    
    
    >>> __init__(root = [1,2,3,4,-99,-99,7,8,9,-99,-99,12,13,-99,14], limit = 1)
    >>> [1,2,3,4,null,null,7,8,9,null,14]
    
    Example 2:
    
    
    >>> __init__(root = [5,4,8,11,null,17,4,7,1,null,null,5,3], limit = 22)
    >>> [5,4,8,11,null,17,4,7,null,null,null,5]
    
    Example 3:
    
    
    >>> __init__(root = [1,2,-3,-5,null,4,null], limit = -1)
    >>> [1,null,-3,4]
    """
def smallestSubsequence(s: str) -> str:
    """
    Given a string s, return the lexicographically smallest subsequence of s that contains all the distinct characters of s exactly once.
    
    Example 1:
    
    >>> smallestSubsequence(s = "bcabc")
    >>> "abc"
    
    Example 2:
    
    >>> smallestSubsequence(s = "cbacdcbc")
    >>> "acdb"
    """
def sumOfDigits(nums: List[int]) -> int:
    """
    Given an integer array nums, return 0 if the sum of the digits of the minimum integer in nums is odd, or 1 otherwise.
    
    Example 1:
    
    >>> sumOfDigits(nums = [34,23,1,24,75,33,54,8])
    >>> 0
    Explanation: The minimal element is 1, and the sum of those digits is 1 which is odd, so the answer is 0.
    
    Example 2:
    
    >>> sumOfDigits(nums = [99,77,33,66,55])
    >>> 1
    Explanation: The minimal element is 33, and the sum of those digits is 3 + 3 = 6 which is even, so the answer is 1.
    """
def highFive(items: List[List[int]]) -> List[List[int]]:
    """
    Given a list of the scores of different students, items, where items[i] = [IDi, scorei] represents one score from a student with IDi, calculate each student's top five average.
    Return the answer as an array of pairs result, where result[j] = [IDj, topFiveAveragej] represents the student with IDj and their top five average. Sort result by IDj in increasing order.
    A student's top five average is calculated by taking the sum of their top five scores and dividing it by 5 using integer division.
    
    Example 1:
    
    >>> highFive(items = [[1,91],[1,92],[2,93],[2,97],[1,60],[2,77],[1,65],[1,87],[1,100],[2,100],[2,76]])
    >>> [[1,87],[2,88]]
    Explanation:
    The student with ID = 1 got scores 91, 92, 60, 65, 87, and 100. Their top five average is (100 + 92 + 91 + 87 + 65) / 5 = 87.
    The student with ID = 2 got scores 93, 97, 77, 100, and 76. Their top five average is (100 + 97 + 93 + 77 + 76) / 5 = 88.6, but with integer division their average converts to 88.
    
    Example 2:
    
    >>> highFive(items = [[1,100],[7,100],[1,100],[7,100],[1,100],[7,100],[1,100],[7,100],[1,100],[7,100]])
    >>> [[1,100],[7,100]]
    """
def expand(s: str) -> List[str]:
    """
    You are given a string s representing a list of words. Each letter in the word has one or more options.
    
    If there is one option, the letter is represented as is.
    If there is more than one option, then curly braces delimit the options. For example, "{a,b,c}" represents options ["a", "b", "c"].
    
    For example, if s = "a{b,c}", the first character is always 'a', but the second character can be 'b' or 'c'. The original list is ["ab", "ac"].
    Return all words that can be formed in this manner, sorted in lexicographical order.
    
    Example 1:
    >>> expand(s = "{a,b}c{d,e}f")
    >>> ["acdf","acef","bcdf","bcef"]
    Example 2:
    >>> expand(s = "abcd")
    >>> ["abcd"]
    """
def confusingNumberII(n: int) -> int:
    """
    A confusing number is a number that when rotated 180 degrees becomes a different number with each digit valid.
    We can rotate digits of a number by 180 degrees to form new digits.
    
    When 0, 1, 6, 8, and 9 are rotated 180 degrees, they become 0, 1, 9, 8, and 6 respectively.
    When 2, 3, 4, 5, and 7 are rotated 180 degrees, they become invalid.
    
    Note that after rotating a number, we can ignore leading zeros.
    
    For example, after rotating 8000, we have 0008 which is considered as just 8.
    
    Given an integer n, return the number of confusing numbers in the inclusive range [1, n].
    
    Example 1:
    
    >>> confusingNumberII(n = 20)
    >>> 6
    Explanation: The confusing numbers are [6,9,10,16,18,19].
    6 converts to 9.
    9 converts to 6.
    10 converts to 01 which is just 1.
    16 converts to 91.
    18 converts to 81.
    19 converts to 61.
    
    Example 2:
    
    >>> confusingNumberII(n = 100)
    >>> 19
    Explanation: The confusing numbers are [6,9,10,16,18,19,60,61,66,68,80,81,86,89,90,91,98,99,100].
    """
def duplicateZeros(arr: List[int]) -> None:
        """
        Do not return anything, modify arr in-place instead.
        """
    """
    Given a fixed-length integer array arr, duplicate each occurrence of zero, shifting the remaining elements to the right.
    Note that elements beyond the length of the original array are not written. Do the above modifications to the input array in place and do not return anything.
    
    Example 1:
    
    >>> duplicateZeros(arr = [1,0,2,3,0,4,5,0])
    >>> [1,0,0,2,3,0,0,4]
    Explanation: After calling your function, the input array is modified to: [1,0,0,2,3,0,0,4]
    
    Example 2:
    
    >>> duplicateZeros(arr = [1,2,3])
    >>> [1,2,3]
    Explanation: After calling your function, the input array is modified to: [1,2,3]
    """
def largestValsFromLabels(values: List[int], labels: List[int], numWanted: int, useLimit: int) -> int:
    """
    You are given n item's value and label as two integer arrays values and labels. You are also given two integers numWanted and useLimit.
    Your task is to find a subset of items with the maximum sum of their values such that:
    
    The number of items is at most numWanted.
    The number of items with the same label is at most useLimit.
    
    Return the maximum sum.
    
    Example 1:
    
    >>> largestValsFromLabels(values = [5,4,3,2,1], labels = [1,1,2,2,3], numWanted = 3, useLimit = 1)
    >>> 9
    Explanation:
    The subset chosen is the first, third, and fifth items with the sum of values 5 + 3 + 1.
    
    Example 2:
    
    >>> largestValsFromLabels(values = [5,4,3,2,1], labels = [1,3,3,3,2], numWanted = 3, useLimit = 2)
    >>> 12
    Explanation:
    The subset chosen is the first, second, and third items with the sum of values 5 + 4 + 3.
    
    Example 3:
    
    >>> largestValsFromLabels(values = [9,8,8,7,6], labels = [0,0,0,1,1], numWanted = 3, useLimit = 1)
    >>> 16
    Explanation:
    The subset chosen is the first and fourth items with the sum of values 9 + 7.
    """
def shortestPathBinaryMatrix(grid: List[List[int]]) -> int:
    """
    Given an n x n binary matrix grid, return the length of the shortest clear path in the matrix. If there is no clear path, return -1.
    A clear path in a binary matrix is a path from the top-left cell (i.e., (0, 0)) to the bottom-right cell (i.e., (n - 1, n - 1)) such that:
    
    All the visited cells of the path are 0.
    All the adjacent cells of the path are 8-directionally connected (i.e., they are different and they share an edge or a corner).
    
    The length of a clear path is the number of visited cells of this path.
    
    Example 1:
    
    
    >>> shortestPathBinaryMatrix(grid = [[0,1],[1,0]])
    >>> 2
    
    Example 2:
    
    
    >>> shortestPathBinaryMatrix(grid = [[0,0,0],[1,1,0],[1,1,0]])
    >>> 4
    
    Example 3:
    
    >>> shortestPathBinaryMatrix(grid = [[1,0,0],[1,1,0],[1,1,0]])
    >>> -1
    """
def shortestCommonSupersequence(str1: str, str2: str) -> str:
    """
    Given two strings str1 and str2, return the shortest string that has both str1 and str2 as subsequences. If there are multiple valid strings, return any of them.
    A string s is a subsequence of string t if deleting some number of characters from t (possibly 0) results in the string s.
    
    Example 1:
    
    >>> shortestCommonSupersequence(str1 = "abac", str2 = "cab")
    >>> "cabac"
    Explanation:
    str1 = "abac" is a subsequence of "cabac" because we can delete the first "c".
    str2 = "cab" is a subsequence of "cabac" because we can delete the last "ac".
    The answer provided is the shortest such string that satisfies these properties.
    
    Example 2:
    
    >>> shortestCommonSupersequence(str1 = "aaaaaaaa", str2 = "aaaaaaaa")
    >>> "aaaaaaaa"
    """
def sampleStats(count: List[int]) -> List[float]:
    """
    You are given a large sample of integers in the range [0, 255]. Since the sample is so large, it is represented by an array count where count[k] is the number of times that k appears in the sample.
    Calculate the following statistics:
    
    minimum: The minimum element in the sample.
    maximum: The maximum element in the sample.
    mean: The average of the sample, calculated as the total sum of all elements divided by the total number of elements.
    median:
    
    If the sample has an odd number of elements, then the median is the middle element once the sample is sorted.
    If the sample has an even number of elements, then the median is the average of the two middle elements once the sample is sorted.
    
    
    mode: The number that appears the most in the sample. It is guaranteed to be unique.
    
    Return the statistics of the sample as an array of floating-point numbers [minimum, maximum, mean, median, mode]. Answers within 10-5 of the actual answer will be accepted.
    
    Example 1:
    
    >>> sampleStats(count = [0,1,3,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])
    >>> [1.00000,3.00000,2.37500,2.50000,3.00000]
    Explanation: The sample represented by count is [1,2,2,2,3,3,3,3].
    The minimum and maximum are 1 and 3 respectively.
    The mean is (1+2+2+2+3+3+3+3) / 8 = 19 / 8 = 2.375.
    Since the size of the sample is even, the median is the average of the two middle elements 2 and 3, which is 2.5.
    The mode is 3 as it appears the most in the sample.
    
    Example 2:
    
    >>> sampleStats(count = [0,4,3,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])
    >>> [1.00000,4.00000,2.18182,2.00000,1.00000]
    Explanation: The sample represented by count is [1,1,1,1,2,2,2,3,3,4,4].
    The minimum and maximum are 1 and 4 respectively.
    The mean is (1+1+1+1+2+2+2+3+3+4+4) / 11 = 24 / 11 = 2.18181818... (for display purposes, the output shows the rounded number 2.18182).
    Since the size of the sample is odd, the median is the middle element 2.
    The mode is 1 as it appears the most in the sample.
    """
def carPooling(trips: List[List[int]], capacity: int) -> bool:
    """
    There is a car with capacity empty seats. The vehicle only drives east (i.e., it cannot turn around and drive west).
    You are given the integer capacity and an array trips where trips[i] = [numPassengersi, fromi, toi] indicates that the ith trip has numPassengersi passengers and the locations to pick them up and drop them off are fromi and toi respectively. The locations are given as the number of kilometers due east from the car's initial location.
    Return true if it is possible to pick up and drop off all passengers for all the given trips, or false otherwise.
    
    Example 1:
    
    >>> carPooling(trips = [[2,1,5],[3,3,7]], capacity = 4)
    >>> false
    
    Example 2:
    
    >>> carPooling(trips = [[2,1,5],[3,3,7]], capacity = 5)
    >>> true
    """
def braceExpansionII(expression: str) -> List[str]:
    """
    Under the grammar given below, strings can represent a set of lowercase words. Let R(expr) denote the set of words the expression represents.
    The grammar can best be understood through simple examples:
    
    Single letters represent a singleton set containing that word.
    
    R("a") = {"a"}
    R("w") = {"w"}
    
    
    When we take a comma-delimited list of two or more expressions, we take the union of possibilities.
    
    R("{a,b,c}") = {"a","b","c"}
    R("{{a,b},{b,c}}") = {"a","b","c"} (notice the final set only contains each word at most once)
    
    
    When we concatenate two expressions, we take the set of possible concatenations between two words where the first word comes from the first expression and the second word comes from the second expression.
    
    R("{a,b}{c,d}") = {"ac","ad","bc","bd"}
    R("a{b,c}{d,e}f{g,h}") = {"abdfg", "abdfh", "abefg", "abefh", "acdfg", "acdfh", "acefg", "acefh"}
    
    
    
    Formally, the three rules for our grammar:
    
    For every lowercase letter x, we have R(x) = {x}.
    For expressions e1, e2, ... , ek with k >= 2, we have R({e1, e2, ...}) = R(e1) ∪ R(e2) ∪ ...
    For expressions e1 and e2, we have R(e1 + e2) = {a + b for (a, b) in R(e1) × R(e2)}, where + denotes concatenation, and × denotes the cartesian product.
    
    Given an expression representing a set of words under the given grammar, return the sorted list of words that the expression represents.
    
    Example 1:
    
    >>> braceExpansionII(expression = "{a,b}{c,{d,e}}")
    >>> ["ac","ad","ae","bc","bd","be"]
    
    Example 2:
    
    >>> braceExpansionII(expression = "{{a,z},a{b,c},{ab,z}}")
    >>> ["a","ab","ac","z"]
    Explanation: Each distinct word is written only once in the final answer.
    """
def twoSumLessThanK(nums: List[int], k: int) -> int:
    """
    Given an array nums of integers and integer k, return the maximum sum such that there exists i < j with nums[i] + nums[j] = sum and sum < k. If no i, j exist satisfying this equation, return -1.
    
    Example 1:
    
    >>> twoSumLessThanK(nums = [34,23,1,24,75,33,54,8], k = 60)
    >>> 58
    Explanation: We can use 34 and 24 to sum 58 which is less than 60.
    
    Example 2:
    
    >>> twoSumLessThanK(nums = [10,20,30], k = 15)
    >>> -1
    Explanation: In this case it is not possible to get a pair sum less that 15.
    """
def numKLenSubstrNoRepeats(s: str, k: int) -> int:
    """
    Given a string s and an integer k, return the number of substrings in s of length k with no repeated characters.
    
    Example 1:
    
    >>> numKLenSubstrNoRepeats(s = "havefunonleetcode", k = 5)
    >>> 6
    Explanation: There are 6 substrings they are: 'havef','avefu','vefun','efuno','etcod','tcode'.
    
    Example 2:
    
    >>> numKLenSubstrNoRepeats(s = "home", k = 5)
    >>> 0
    Explanation: Notice k can be larger than the length of s. In this case, it is not possible to find any substring.
    """
def earliestAcq(logs: List[List[int]], n: int) -> int:
    """
    There are n people in a social group labeled from 0 to n - 1. You are given an array logs where logs[i] = [timestampi, xi, yi] indicates that xi and yi will be friends at the time timestampi.
    Friendship is symmetric. That means if a is friends with b, then b is friends with a. Also, person a is acquainted with a person b if a is friends with b, or a is a friend of someone acquainted with b.
    Return the earliest time for which every person became acquainted with every other person. If there is no such earliest time, return -1.
    
    Example 1:
    
    >>> earliestAcq(logs = [[20190101,0,1],[20190104,3,4],[20190107,2,3],[20190211,1,5],[20190224,2,4],[20190301,0,3],[20190312,1,2],[20190322,4,5]], n = 6)
    >>> 20190301
    Explanation:
    The first event occurs at timestamp = 20190101, and after 0 and 1 become friends, we have the following friendship groups [0,1], [2], [3], [4], [5].
    The second event occurs at timestamp = 20190104, and after 3 and 4 become friends, we have the following friendship groups [0,1], [2], [3,4], [5].
    The third event occurs at timestamp = 20190107, and after 2 and 3 become friends, we have the following friendship groups [0,1], [2,3,4], [5].
    The fourth event occurs at timestamp = 20190211, and after 1 and 5 become friends, we have the following friendship groups [0,1,5], [2,3,4].
    The fifth event occurs at timestamp = 20190224, and as 2 and 4 are already friends, nothing happens.
    The sixth event occurs at timestamp = 20190301, and after 0 and 3 become friends, we all become friends.
    
    Example 2:
    
    >>> earliestAcq(logs = [[0,2,0],[1,0,1],[3,0,3],[4,1,2],[7,3,1]], n = 4)
    >>> 3
    Explanation: At timestamp = 3, all the persons (i.e., 0, 1, 2, and 3) become friends.
    """
def maximumMinimumPath(grid: List[List[int]]) -> int:
    """
    Given an m x n integer matrix grid, return the maximum score of a path starting at (0, 0) and ending at (m - 1, n - 1) moving in the 4 cardinal directions.
    The score of a path is the minimum value in that path.
    
    For example, the score of the path 8 → 4 → 5 → 9 is 4.
    
    
    Example 1:
    
    
    >>> maximumMinimumPath(grid = [[5,4,5],[1,2,6],[7,4,6]])
    >>> 4
    Explanation: The path with the maximum score is highlighted in yellow.
    
    Example 2:
    
    
    >>> maximumMinimumPath(grid = [[2,2,1,2,2,2],[1,2,2,2,1,2]])
    >>> 2
    
    Example 3:
    
    
    >>> maximumMinimumPath(grid = [[3,4,6,3,4],[0,2,1,1,7],[8,8,3,2,7],[3,2,4,9,8],[4,1,2,0,0],[4,6,5,4,3]])
    >>> 3
    """
def distributeCandies(candies: int, num_people: int) -> List[int]:
    """
    We distribute some number of candies, to a row of n = num_people people in the following way:
    We then give 1 candy to the first person, 2 candies to the second person, and so on until we give n candies to the last person.
    Then, we go back to the start of the row, giving n + 1 candies to the first person, n + 2 candies to the second person, and so on until we give 2 * n candies to the last person.
    This process repeats (with us giving one more candy each time, and moving to the start of the row after we reach the end) until we run out of candies.  The last person will receive all of our remaining candies (not necessarily one more than the previous gift).
    Return an array (of length num_people and sum candies) that represents the final distribution of candies.
    
    Example 1:
    
    >>> distributeCandies(candies = 7, num_people = 4)
    >>> [1,2,3,1]
    Explanation:
    On the first turn, ans[0] += 1, and the array is [1,0,0,0].
    On the second turn, ans[1] += 2, and the array is [1,2,0,0].
    On the third turn, ans[2] += 3, and the array is [1,2,3,0].
    On the fourth turn, ans[3] += 1 (because there is only one candy left), and the final array is [1,2,3,1].
    
    Example 2:
    
    >>> distributeCandies(candies = 10, num_people = 3)
    >>> [5,2,3]
    Explanation:
    On the first turn, ans[0] += 1, and the array is [1,0,0].
    On the second turn, ans[1] += 2, and the array is [1,2,0].
    On the third turn, ans[2] += 3, and the array is [1,2,3].
    On the fourth turn, ans[0] += 4, and the final array is [5,2,3].
    """
def pathInZigZagTree(label: int) -> List[int]:
    """
    In an infinite binary tree where every node has two children, the nodes are labelled in row order.
    In the odd numbered rows (ie., the first, third, fifth,...), the labelling is left to right, while in the even numbered rows (second, fourth, sixth,...), the labelling is right to left.
    
    Given the label of a node in this tree, return the labels in the path from the root of the tree to the node with that label.
    
    Example 1:
    
    >>> pathInZigZagTree(label = 14)
    >>> [1,3,4,14]
    
    Example 2:
    
    >>> pathInZigZagTree(label = 26)
    >>> [1,2,6,10,26]
    """
def minHeightShelves(books: List[List[int]], shelfWidth: int) -> int:
    """
    You are given an array books where books[i] = [thicknessi, heighti] indicates the thickness and height of the ith book. You are also given an integer shelfWidth.
    We want to place these books in order onto bookcase shelves that have a total width shelfWidth.
    We choose some of the books to place on this shelf such that the sum of their thickness is less than or equal to shelfWidth, then build another level of the shelf of the bookcase so that the total height of the bookcase has increased by the maximum height of the books we just put down. We repeat this process until there are no more books to place.
    Note that at each step of the above process, the order of the books we place is the same order as the given sequence of books.
    
    For example, if we have an ordered list of 5 books, we might place the first and second book onto the first shelf, the third book on the second shelf, and the fourth and fifth book on the last shelf.
    
    Return the minimum possible height that the total bookshelf can be after placing shelves in this manner.
    
    Example 1:
    
    
    >>> minHeightShelves(books = [[1,1],[2,3],[2,3],[1,1],[1,1],[1,1],[1,2]], shelfWidth = 4)
    >>> 6
    Explanation:
    The sum of the heights of the 3 shelves is 1 + 3 + 2 = 6.
    Notice that book number 2 does not have to be on the first shelf.
    
    Example 2:
    
    >>> minHeightShelves(books = [[1,3],[2,4],[3,2]], shelfWidth = 6)
    >>> 4
    """
def parseBoolExpr(expression: str) -> bool:
    """
    A boolean expression is an expression that evaluates to either true or false. It can be in one of the following shapes:
    
    't' that evaluates to true.
    'f' that evaluates to false.
    '!(subExpr)' that evaluates to the logical NOT of the inner expression subExpr.
    '&(subExpr1, subExpr2, ..., subExprn)' that evaluates to the logical AND of the inner expressions subExpr1, subExpr2, ..., subExprn where n >= 1.
    '|(subExpr1, subExpr2, ..., subExprn)' that evaluates to the logical OR of the inner expressions subExpr1, subExpr2, ..., subExprn where n >= 1.
    
    Given a string expression that represents a boolean expression, return the evaluation of that expression.
    It is guaranteed that the given expression is valid and follows the given rules.
    
    Example 1:
    
    >>> parseBoolExpr(expression = "&(|(f))")
    >>> false
    Explanation:
    First, evaluate |(f) --> f. The expression is now "&(f)".
    Then, evaluate &(f) --> f. The expression is now "f".
    Finally, return false.
    
    Example 2:
    
    >>> parseBoolExpr(expression = "|(f,f,f,t)")
    >>> true
    Explanation: The evaluation of (false OR false OR false OR true) is true.
    
    Example 3:
    
    >>> parseBoolExpr(expression = "!(&(f,t))")
    >>> true
    Explanation:
    First, evaluate &(f,t) --> (false AND true) --> false --> f. The expression is now "!(f)".
    Then, evaluate !(f) --> NOT false --> true. We return true.
    """