Prompt:
from typing import List
def arrayPairSum(nums: List[int]) -> int:
    """
    Given an integer array nums of 2n integers, group these integers into n pairs (a1, b1), (a2, b2), ..., (an, bn) such that the sum of min(ai, bi) for all i is maximized. Return the maximized sum.

    Example 1:

    >>> arrayPairSum(nums = [1,4,3,2])
    >>> 4
    Explanation: All possible pairings (ignoring the ordering of elements) are:
    1. (1, 4), (2, 3) -> min(1, 4) + min(2, 3) = 1 + 2 = 3
    2. (1, 3), (2, 4) -> min(1, 3) + min(2, 4) = 1 + 2 = 3
    3. (1, 2), (3, 4) -> min(1, 2) + min(3, 4) = 1 + 3 = 4
    So the maximum possible sum is 4.
    Example 2:

    >>> arrayPairSum(nums = [6,2,6,5,1,2])
    >>> 9
    Explanation: The optimal pairing is (2, 1), (2, 5), (6, 6). min(2, 1) + min(2, 5) + min(6, 6) = 1 + 2 + 6 = 9.
    """


Prompt:
from typing import List
def longestLine(mat: List[List[int]]) -> int:
    """
    Given an m x n binary matrix mat, return the length of the longest line of consecutive one in the matrix.
    The line could be horizontal, vertical, diagonal, or anti-diagonal.

    Example 1:

    >>> longestLine(mat = [[0,1,1,0],[0,1,1,0],[0,0,0,1]])
    >>> 3

    Example 2:

    >>> longestLine(mat = [[1,1,1,1],[0,1,1,0],[0,0,0,1]])
    >>> 4
    """


Prompt:
from typing import Optional
class TreeNode:
    def __init__(val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def findTilt(root: Optional[TreeNode]) -> int:
"""
Given the root of a binary tree, return the sum of every tree node's tilt.
The tilt of a tree node is the absolute difference between the sum of all left subtree node values and all right subtree node values. If a node does not have a left child, then the sum of the left subtree node values is treated as 0. The rule is similar if the node does not have a right child.

Example 1:

>>> findTilt(root = [1,2,3])
>>> 1
Explanation:
Tilt of node 2 : |0-0| = 0 (no children)
Tilt of node 3 : |0-0| = 0 (no children)
Tilt of node 1 : |2-3| = 1 (left subtree is just left child, so sum is 2; right subtree is just right child, so sum is 3)
Sum of every tilt : 0 + 0 + 1 = 1

Example 2:

>>> findTilt(root = [4,2,9,3,5,null,7])
>>> 15
Explanation:
Tilt of node 3 : |0-0| = 0 (no children)
Tilt of node 5 : |0-0| = 0 (no children)
Tilt of node 7 : |0-0| = 0 (no children)
Tilt of node 2 : |3-5| = 2 (left subtree is just left child, so sum is 3; right subtree is just right child, so sum is 5)
Tilt of node 9 : |0-7| = 7 (no left child, so sum is 0; right subtree is just right child, so sum is 7)
Tilt of node 4 : |(3+5+2)-(9+7)| = |10-16| = 6 (left subtree values are 3, 5, and 2, which sums to 10; right subtree values are 9 and 7, which sums to 16)
Sum of every tilt : 0 + 0 + 0 + 2 + 7 + 6 = 15

Example 3:

>>> findTilt(root = [21,7,14,1,1,2,2,3,3])
>>> 9
"""


Prompt:
def nearestPalindromic(n: str) -> str:
    """
    Given a string n representing an integer, return the closest integer (not including itself), which is a palindrome. If there is a tie, return the smaller one.
    The closest is defined as the absolute difference minimized between two integers.

    Example 1:

    >>> nearestPalindromic(n = "123")
    >>> "121"

    Example 2:

    >>> nearestPalindromic(n = "1")
    >>> "0"
    Explanation: 0 and 2 are the closest palindromes but we return the smallest which is 0.
    """


Prompt:
from typing import List
def arrayNesting(nums: List[int]) -> int:
    """
    You are given an integer array nums of length n where nums is a permutation of the numbers in the range [0, n - 1].
    You should build a set s[k] = {nums[k], nums[nums[k]], nums[nums[nums[k]]], ... } subjected to the following rule:

    The first element in s[k] starts with the selection of the element nums[k] of index = k.
    The next element in s[k] should be nums[nums[k]], and then nums[nums[nums[k]]], and so on.
    We stop adding right before a duplicate element occurs in s[k].

    Return the longest length of a set s[k].

    Example 1:

    >>> arrayNesting(nums = [5,4,0,3,1,6,2])
    >>> 4
    Explanation:
    nums[0] = 5, nums[1] = 4, nums[2] = 0, nums[3] = 3, nums[4] = 1, nums[5] = 6, nums[6] = 2.
    One of the longest sets s[k]:
    s[0] = {nums[0], nums[5], nums[6], nums[2]} = {5, 6, 2, 0}

    Example 2:

    >>> arrayNesting(nums = [0,1,2])
    >>> 1
    """


Prompt:
from typing import List
def matrixReshape(mat: List[List[int]], r: int, c: int) -> List[List[int]]:
    """
    In MATLAB, there is a handy function called reshape which can reshape an m x n matrix into a new one with a different size r x c keeping its original data.
    You are given an m x n matrix mat and two integers r and c representing the number of rows and the number of columns of the wanted reshaped matrix.
    The reshaped matrix should be filled with all the elements of the original matrix in the same row-traversing order as they were.
    If the reshape operation with given parameters is possible and legal, output the new reshaped matrix; Otherwise, output the original matrix.

    Example 1:

    >>> matrixReshape(mat = [[1,2],[3,4]], r = 1, c = 4)
    >>> [[1,2,3,4]]

    Example 2:

    >>> matrixReshape(mat = [[1,2],[3,4]], r = 2, c = 4)
    >>> [[1,2],[3,4]]
    """


Prompt:
def checkInclusion(s1: str, s2: str) -> bool:
    """
    Given two strings s1 and s2, return true if s2 contains a permutation of s1, or false otherwise.
    In other words, return true if one of s1's permutations is the substring of s2.

    Example 1:

    >>> checkInclusion(s1 = "ab", s2 = "eidbaooo")
    >>> true
    Explanation: s2 contains one permutation of s1 ("ba").

    Example 2:

    >>> checkInclusion(s1 = "ab", s2 = "eidboaoo")
    >>> false
    """


Prompt:
from typing import List
def maxVacationDays(flights: List[List[int]], days: List[List[int]]) -> int:
    """
    LeetCode wants to give one of its best employees the option to travel among n cities to collect algorithm problems. But all work and no play makes Jack a dull boy, you could take vacations in some particular cities and weeks. Your job is to schedule the traveling to maximize the number of vacation days you could take, but there are certain rules and restrictions you need to follow.
    Rules and restrictions:

    You can only travel among n cities, represented by indexes from 0 to n - 1. Initially, you are in the city indexed 0 on Monday.
    The cities are connected by flights. The flights are represented as an n x n matrix (not necessarily symmetrical), called flights representing the airline status from the city i to the city j. If there is no flight from the city i to the city j, flights[i][j] == 0; Otherwise, flights[i][j] == 1. Also, flights[i][i] == 0 for all i.
    You totally have k weeks (each week has seven days) to travel. You can only take flights at most once per day and can only take flights on each week's Monday morning. Since flight time is so short, we do not consider the impact of flight time.
    For each city, you can only have restricted vacation days in different weeks, given an n x k matrix called days representing this relationship. For the value of days[i][j], it represents the maximum days you could take a vacation in the city i in the week j.
    You could stay in a city beyond the number of vacation days, but you should work on the extra days, which will not be counted as vacation days.
    If you fly from city A to city B and take the vacation on that day, the deduction towards vacation days will count towards the vacation days of city B in that week.
    We do not consider the impact of flight hours on the calculation of vacation days.

    Given the two matrices flights and days, return the maximum vacation days you could take during k weeks.

    Example 1:

    >>> maxVacationDays(flights = [[0,1,1],[1,0,1],[1,1,0]], days = [[1,3,1],[6,0,3],[3,3,3]])
    >>> 12
    Explanation:
    One of the best strategies is:
    1st week : fly from city 0 to city 1 on Monday, and play 6 days and work 1 day.
    (Although you start at city 0, we could also fly to and start at other cities since it is Monday.)
    2nd week : fly from city 1 to city 2 on Monday, and play 3 days and work 4 days.
    3rd week : stay at city 2, and play 3 days and work 4 days.
    Ans = 6 + 3 + 3 = 12.

    Example 2:

    >>> maxVacationDays(flights = [[0,0,0],[0,0,0],[0,0,0]], days = [[1,1,1],[7,7,7],[7,7,7]])
    >>> 3
    Explanation:
    Since there are no flights that enable you to move to another city, you have to stay at city 0 for the whole 3 weeks.
    For each week, you only have one day to play and six days to work.
    So the maximum number of vacation days is 3.
    Ans = 1 + 1 + 1 = 3.

    Example 3:

    >>> maxVacationDays(flights = [[0,1,1],[1,0,1],[1,1,0]], days = [[7,0,0],[0,7,0],[0,0,7]])
    >>> 21
    Explanation:
    One of the best strategies is:
    1st week : stay at city 0, and play 7 days.
    2nd week : fly from city 0 to city 1 on Monday, and play 7 days.
    3rd week : fly from city 1 to city 2 on Monday, and play 7 days.
    Ans = 7 + 7 + 7 = 21
    """


Prompt:
from typing import Optional
class TreeNode:
    def __init__(val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def isSubtree(root: Optional[TreeNode], subRoot: Optional[TreeNode]) -> bool:
"""
Given the roots of two binary trees root and subRoot, return true if there is a subtree of root with the same structure and node values of subRoot and false otherwise.
A subtree of a binary tree tree is a tree that consists of a node in tree and all of this node's descendants. The tree tree could also be considered as a subtree of itself.

Example 1:

>>> isSubtree(root = [3,4,5,1,2], subRoot = [4,1,2])
>>> true

Example 2:

>>> isSubtree(root = [3,4,5,1,2,null,null,null,null,0], subRoot = [4,1,2])
>>> false
"""


Prompt:
from typing import List
def minDistance(height: int, width: int, tree: List[int], squirrel: List[int], nuts: List[List[int]]) -> int:
    """
    You are given two integers height and width representing a garden of size height x width. You are also given:

    an array tree where tree = [treer, treec] is the position of the tree in the garden,
    an array squirrel where squirrel = [squirrelr, squirrelc] is the position of the squirrel in the garden,
    and an array nuts where nuts[i] = [nutir, nutic] is the position of the ith nut in the garden.

    The squirrel can only take at most one nut at one time and can move in four directions: up, down, left, and right, to the adjacent cell.
    Return the minimal distance for the squirrel to collect all the nuts and put them under the tree one by one.
    The distance is the number of moves.

    Example 1:

    >>> minDistance(height = 5, width = 7, tree = [2,2], squirrel = [4,4], nuts = [[3,0], [2,5]])
    >>> 12
    Explanation: The squirrel should go to the nut at [2, 5] first to achieve a minimal distance.

    Example 2:

    >>> minDistance(height = 1, width = 3, tree = [0,1], squirrel = [0,0], nuts = [[0,2]])
    >>> 3
    """


Prompt:
from typing import List
def distributeCandies(candyType: List[int]) -> int:
    """
    Alice has n candies, where the ith candy is of type candyType[i]. Alice noticed that she started to gain weight, so she visited a doctor.
    The doctor advised Alice to only eat n / 2 of the candies she has (n is always even). Alice likes her candies very much, and she wants to eat the maximum number of different types of candies while still following the doctor's advice.
    Given the integer array candyType of length n, return the maximum number of different types of candies she can eat if she only eats n / 2 of them.

    Example 1:

    >>> distributeCandies(candyType = [1,1,2,2,3,3])
    >>> 3
    Explanation: Alice can only eat 6 / 2 = 3 candies. Since there are only 3 types, she can eat one of each type.

    Example 2:

    >>> distributeCandies(candyType = [1,1,2,3])
    >>> 2
    Explanation: Alice can only eat 4 / 2 = 2 candies. Whether she eats types [1,2], [1,3], or [2,3], she still can only eat 2 different types.

    Example 3:

    >>> distributeCandies(candyType = [6,6,6,6])
    >>> 1
    Explanation: Alice can only eat 4 / 2 = 2 candies. Even though she can eat 2 candies, she only has 1 type.
    """


Prompt:
def findPaths(m: int, n: int, maxMove: int, startRow: int, startColumn: int) -> int:
    """
    There is an m x n grid with a ball. The ball is initially at the position [startRow, startColumn]. You are allowed to move the ball to one of the four adjacent cells in the grid (possibly out of the grid crossing the grid boundary). You can apply at most maxMove moves to the ball.
    Given the five integers m, n, maxMove, startRow, startColumn, return the number of paths to move the ball out of the grid boundary. Since the answer can be very large, return it modulo 109 + 7.

    Example 1:

    >>> findPaths(m = 2, n = 2, maxMove = 2, startRow = 0, startColumn = 0)
    >>> 6

    Example 2:

    >>> findPaths(m = 1, n = 3, maxMove = 3, startRow = 0, startColumn = 1)
    >>> 12
    """


Prompt:
from typing import List
def findUnsortedSubarray(nums: List[int]) -> int:
    """
    Given an integer array nums, you need to find one continuous subarray such that if you only sort this subarray in non-decreasing order, then the whole array will be sorted in non-decreasing order.
    Return the shortest such subarray and output its length.

    Example 1:

    >>> findUnsortedSubarray(nums = [2,6,4,8,10,9,15])
    >>> 5
    Explanation: You need to sort [6, 4, 8, 10, 9] in ascending order to make the whole array sorted in ascending order.

    Example 2:

    >>> findUnsortedSubarray(nums = [1,2,3,4])
    >>> 0

    Example 3:

    >>> findUnsortedSubarray(nums = [1])
    >>> 0
    """


Prompt:
from typing import List
def killProcess(pid: List[int], ppid: List[int], kill: int) -> List[int]:
    """
    You have n processes forming a rooted tree structure. You are given two integer arrays pid and ppid, where pid[i] is the ID of the ith process and ppid[i] is the ID of the ith process's parent process.
    Each process has only one parent process but may have multiple children processes. Only one process has ppid[i] = 0, which means this process has no parent process (the root of the tree).
    When a process is killed, all of its children processes will also be killed.
    Given an integer kill representing the ID of a process you want to kill, return a list of the IDs of the processes that will be killed. You may return the answer in any order.

    Example 1:

    >>> killProcess(pid = [1,3,10,5], ppid = [3,0,5,3], kill = 5)
    >>> [5,10]
    Explanation: The processes colored in red are the processes that should be killed.

    Example 2:

    >>> killProcess(pid = [1], ppid = [0], kill = 1)
    >>> [1]
    """


Prompt:
def minDistance(word1: str, word2: str) -> int:
    """
    Given two strings word1 and word2, return the minimum number of steps required to make word1 and word2 the same.
    In one step, you can delete exactly one character in either string.

    Example 1:

    >>> minDistance(word1 = "sea", word2 = "eat")
    >>> 2
    Explanation: You need one step to make "sea" to "ea" and another step to make "eat" to "ea".

    Example 2:

    >>> minDistance(word1 = "leetcode", word2 = "etco")
    >>> 4
    """


Prompt:
from typing import List
def outerTrees(trees: List[List[int]]) -> List[List[int]]:
    """
    You are given an array trees where trees[i] = [xi, yi] represents the location of a tree in the garden.
    Fence the entire garden using the minimum length of rope, as it is expensive. The garden is well-fenced only if all the trees are enclosed.
    Return the coordinates of trees that are exactly located on the fence perimeter. You may return the answer in any order.

    Example 1:

    >>> outerTrees(trees = [[1,1],[2,2],[2,0],[2,4],[3,3],[4,2]])
    >>> [[1,1],[2,0],[4,2],[3,3],[2,4]]
    Explanation: All the trees will be on the perimeter of the fence except the tree at [2, 2], which will be inside the fence.

    Example 2:

    >>> outerTrees(trees = [[1,2],[2,2],[4,2]])
    >>> [[4,2],[2,2],[1,2]]
    Explanation: The fence forms a line that passes through all the trees.
    """


Prompt:
def isValid(code: str) -> bool:
    """
    Given a string representing a code snippet, implement a tag validator to parse the code and return whether it is valid.
    A code snippet is valid if all the following rules hold:

    The code must be wrapped in a valid closed tag. Otherwise, the code is invalid.
    A closed tag (not necessarily valid) has exactly the following format : TAG_CONTENT. Among them,  is the start tag, and  is the end tag. The TAG_NAME in start and end tags should be the same. A closed tag is valid if and only if the TAG_NAME and TAG_CONTENT are valid.
    A valid TAG_NAME only contain upper-case letters, and has length in range [1,9]. Otherwise, the TAG_NAME is invalid.
    A valid TAG_CONTENT may contain other valid closed tags, cdata and any characters (see note1) EXCEPT unmatched <, unmatched start and end tag, and unmatched or closed tags with invalid TAG_NAME. Otherwise, the TAG_CONTENT is invalid.
    A start tag is unmatched if no end tag exists with the same TAG_NAME, and vice versa. However, you also need to consider the issue of unbalanced when tags are nested.
    A < is unmatched if you cannot find a subsequent >. And when you find a < or , all the subsequent characters until the next > should be parsed as TAG_NAME (not necessarily valid).
    The cdata has the following format : CDATA_CONTENT. The range of CDATA_CONTENT is defined as the characters between </code> and the <b>first subsequent</b> <code>.
    CDATA_CONTENT may contain any characters. The function of cdata is to forbid the validator to parse CDATA_CONTENT, so even it has some characters that can be parsed as tag (no matter valid or invalid), you should treat it as regular characters.

    Example 1:

    >>> isValid(code = "This is the first line <div>")
    >>> true
    Explanation:
    The code is wrapped in a closed tag :  and .
    The TAG_NAME is valid, the TAG_CONTENT consists of some characters and cdata.
    Although CDATA_CONTENT has an unmatched start tag with invalid TAG_NAME, it should be considered as plain text, not parsed as a tag.
    So TAG_CONTENT is valid, and then the code is valid. Thus return true.

    Example 2:

    >>> isValid(code = ">>  ![cdata[]] <div>]>]]>>]")
    >>> true
    Explanation:
    We first separate the code into : start_tag|tag_content|end_tag.
    start_tag -> ""
    end_tag -> ""
    tag_content could also be separated into : text1|cdata|text2.
    text1 -> ">>  ![cdata[]] "
    cdata -> "<div>]>", where the CDATA_CONTENT is "]>"
    text2 -> "]]>>]"
    The reason why start_tag is NOT ">>" is because of the rule 6.
    The reason why cdata is NOT "<div>]>]]>" is because of the rule 7.

    Example 3:

    >>> isValid(code = "      ")
    >>> false
    Explanation: Unbalanced. If "" is closed, then "" must be unmatched, and vice versa.
    """


Prompt:
def fractionAddition(expression: str) -> str:
    """
    Given a string expression representing an expression of fraction addition and subtraction, return the calculation result in string format.
    The final result should be an irreducible fraction. If your final result is an integer, change it to the format of a fraction that has a denominator 1. So in this case, 2 should be converted to 2/1.

    Example 1:

    >>> fractionAddition(expression = "-1/2+1/2")
    >>> "0/1"

    Example 2:

    >>> fractionAddition(expression = "-1/2+1/2+1/3")
    >>> "1/3"

    Example 3:

    >>> fractionAddition(expression = "1/3-1/2")
    >>> "-1/6"
    """


Prompt:
from typing import List
def validSquare(p1: List[int], p2: List[int], p3: List[int], p4: List[int]) -> bool:
    """
    Given the coordinates of four points in 2D space p1, p2, p3 and p4, return true if the four points construct a square.
    The coordinate of a point pi is represented as [xi, yi]. The input is not given in any order.
    A valid square has four equal sides with positive length and four equal angles (90-degree angles).

    Example 1:

    >>> validSquare(p1 = [0,0], p2 = [1,1], p3 = [1,0], p4 = [0,1])
    >>> true

    Example 2:

    >>> validSquare(p1 = [0,0], p2 = [1,1], p3 = [1,0], p4 = [0,12])
    >>> false

    Example 3:

    >>> validSquare(p1 = [1,0], p2 = [-1,0], p3 = [0,1], p4 = [0,-1])
    >>> true
    """


Prompt:
from typing import List
def findLHS(nums: List[int]) -> int:
    """
    We define a harmonious array as an array where the difference between its maximum value and its minimum value is exactly 1.
    Given an integer array nums, return the length of its longest harmonious subsequence among all its possible subsequences.

    Example 1:

    >>> findLHS(nums = [1,3,2,2,5,2,3,7])
    >>> 5
    Explanation:
    The longest harmonious subsequence is [3,2,2,2,3].

    Example 2:

    >>> findLHS(nums = [1,2,3,4])
    >>> 2
    Explanation:
    The longest harmonious subsequences are [1,2], [2,3], and [3,4], all of which have a length of 2.

    Example 3:

    >>> findLHS(nums = [1,1,1,1])
    >>> 0
    Explanation:
    No harmonic subsequence exists.
    """


Prompt:
from typing import List
def maxCount(m: int, n: int, ops: List[List[int]]) -> int:
    """
    You are given an m x n matrix M initialized with all 0's and an array of operations ops, where ops[i] = [ai, bi] means M[x][y] should be incremented by one for all 0 <= x < ai and 0 <= y < bi.
    Count and return the number of maximum integers in the matrix after performing all the operations.

    Example 1:

    >>> maxCount(m = 3, n = 3, ops = [[2,2],[3,3]])
    >>> 4
    Explanation: The maximum integer in M is 2, and there are four of it in M. So return 4.

    Example 2:

    >>> maxCount(m = 3, n = 3, ops = [[2,2],[3,3],[3,3],[3,3],[2,2],[3,3],[3,3],[3,3],[2,2],[3,3],[3,3],[3,3]])
    >>> 4

    Example 3:

    >>> maxCount(m = 3, n = 3, ops = [])
    >>> 9
    """


Prompt:
from typing import List
def findRestaurant(list1: List[str], list2: List[str]) -> List[str]:
    """
    Given two arrays of strings list1 and list2, find the common strings with the least index sum.
    A common string is a string that appeared in both list1 and list2.
    A common string with the least index sum is a common string such that if it appeared at list1[i] and list2[j] then i + j should be the minimum value among all the other common strings.
    Return all the common strings with the least index sum. Return the answer in any order.

    Example 1:

    >>> findRestaurant(list1 = ["Shogun","Tapioca Express","Burger King","KFC"], list2 = ["Piatti","The Grill at Torrey Pines","Hungry Hunter Steakhouse","Shogun"])
    >>> ["Shogun"]
    Explanation: The only common string is "Shogun".

    Example 2:

    >>> findRestaurant(list1 = ["Shogun","Tapioca Express","Burger King","KFC"], list2 = ["KFC","Shogun","Burger King"])
    >>> ["Shogun"]
    Explanation: The common string with the least index sum is "Shogun" with index sum = (0 + 1) = 1.

    Example 3:

    >>> findRestaurant(list1 = ["happy","sad","good"], list2 = ["sad","happy","good"])
    >>> ["sad","happy"]
    Explanation: There are three common strings:
    "happy" with index sum = (0 + 1) = 1.
    "sad" with index sum = (1 + 0) = 1.
    "good" with index sum = (2 + 2) = 4.
    The strings with the least index sum are "sad" and "happy".
    """


Prompt:
def findIntegers(n: int) -> int:
    """
    Given a positive integer n, return the number of the integers in the range [0, n] whose binary representations do not contain consecutive ones.

    Example 1:

    >>> findIntegers(n = 5)
    >>> 5
    Explanation:
    Here are the non-negative integers <= 5 with their corresponding binary representations:
    0 : 0
    1 : 1
    2 : 10
    3 : 11
    4 : 100
    5 : 101
    Among them, only integer 3 disobeys the rule (two consecutive ones) and the other 5 satisfy the rule.

    Example 2:

    >>> findIntegers(n = 1)
    >>> 2

    Example 3:

    >>> findIntegers(n = 2)
    >>> 3
    """


Prompt:
from typing import List
def canPlaceFlowers(flowerbed: List[int], n: int) -> bool:
    """
    You have a long flowerbed in which some of the plots are planted, and some are not. However, flowers cannot be planted in adjacent plots.
    Given an integer array flowerbed containing 0's and 1's, where 0 means empty and 1 means not empty, and an integer n, return true if n new flowers can be planted in the flowerbed without violating the no-adjacent-flowers rule and false otherwise.

    Example 1:
    >>> canPlaceFlowers(flowerbed = [1,0,0,0,1], n = 1)
    >>> true
    Example 2:
    >>> canPlaceFlowers(flowerbed = [1,0,0,0,1], n = 2)
    >>> false
    """


Prompt:
from typing import Any, Optional
class TreeNode:
    def __init__(val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def tree2str(root: Optional[TreeNode]) -> str:
"""
Given the root node of a binary tree, your task is to create a string representation of the tree following a specific set of formatting rules. The representation should be based on a preorder traversal of the binary tree and must adhere to the following guidelines:

Node Representation: Each node in the tree should be represented by its integer value.

Parentheses for Children: If a node has at least one child (either left or right), its children should be represented inside parentheses. Specifically:

If a node has a left child, the value of the left child should be enclosed in parentheses immediately following the node's value.
If a node has a right child, the value of the right child should also be enclosed in parentheses. The parentheses for the right child should follow those of the left child.

Omitting Empty Parentheses: Any empty parentheses pairs (i.e., ()) should be omitted from the final string representation of the tree, with one specific exception: when a node has a right child but no left child. In such cases, you must include an empty pair of parentheses to indicate the absence of the left child. This ensures that the one-to-one mapping between the string representation and the original binary tree structure is maintained.
In summary, empty parentheses pairs should be omitted when a node has only a left child or no children. However, when a node has a right child but no left child, an empty pair of parentheses must precede the representation of the right child to reflect the tree's structure accurately.

Example 1:

>>> tree2str(root = [1,2,3,4])
>>> "1(2(4))(3)"
Explanation: Originally, it needs to be "1(2(4)())(3()())", but you need to omit all the empty parenthesis pairs. And it will be "1(2(4))(3)".

Example 2:

>>> tree2str(root = [1,2,3,null,4])
>>> "1(2()(4))(3)"
Explanation: Almost the same as the first example, except the () after 2 is necessary to indicate the absence of a left child for 2 and the presence of a right child.
"""


Prompt:
from typing import List
def findDuplicate(paths: List[str]) -> List[List[str]]:
    """
    Given a list paths of directory info, including the directory path, and all the files with contents in this directory, return all the duplicate files in the file system in terms of their paths. You may return the answer in any order.
    A group of duplicate files consists of at least two files that have the same content.
    A single directory info string in the input list has the following format:

    "root/d1/d2/.../dm f1.txt(f1_content) f2.txt(f2_content) ... fn.txt(fn_content)"

    It means there are n files (f1.txt, f2.txt ... fn.txt) with content (f1_content, f2_content ... fn_content) respectively in the directory "root/d1/d2/.../dm". Note that n >= 1 and m >= 0. If m = 0, it means the directory is just the root directory.
    The output is a list of groups of duplicate file paths. For each group, it contains all the file paths of the files that have the same content. A file path is a string that has the following format:

    "directory_path/file_name.txt"

    Example 1:
    >>> findDuplicate(paths = ["root/a 1.txt(abcd) 2.txt(efgh)","root/c 3.txt(abcd)","root/c/d 4.txt(efgh)","root 4.txt(efgh)"])
    >>> [["root/a/2.txt","root/c/d/4.txt","root/4.txt"],["root/a/1.txt","root/c/3.txt"]]
    Example 2:
    >>> findDuplicate(paths = ["root/a 1.txt(abcd) 2.txt(efgh)","root/c 3.txt(abcd)","root/c/d 4.txt(efgh)"])
    >>> [["root/a/2.txt","root/c/d/4.txt"],["root/a/1.txt","root/c/3.txt"]]
    """


Prompt:
from typing import List
def triangleNumber(nums: List[int]) -> int:
    """
    Given an integer array nums, return the number of triplets chosen from the array that can make triangles if we take them as side lengths of a triangle.

    Example 1:

    >>> triangleNumber(nums = [2,2,3,4])
    >>> 3
    Explanation: Valid combinations are:
    2,3,4 (using the first 2)
    2,3,4 (using the second 2)
    2,2,3

    Example 2:

    >>> triangleNumber(nums = [4,2,3,4])
    >>> 4
    """


Prompt:
from typing import List
def addBoldTag(s: str, words: List[str]) -> str:
    """
    You are given a string s and an array of strings words.
    You should add a closed pair of bold tag  and  to wrap the substrings in s that exist in words.

    If two such substrings overlap, you should wrap them together with only one pair of closed bold-tag.
    If two substrings wrapped by bold tags are consecutive, you should combine them.

    Return s after adding the bold tags.

    Example 1:

    >>> addBoldTag(s = "abcxyz123", words = ["abc","123"])
    >>> "abcxyz123"
    Explanation: The two strings of words are substrings of s as following: "abcxyz123".
    We add  before each substring and  after each substring.

    Example 2:

    >>> addBoldTag(s = "aaabbb", words = ["aa","b"])
    >>> "aaabbb"
    Explanation:
    "aa" appears as a substring two times: "aaabbb" and "aaabbb".
    "b" appears as a substring three times: "aaabbb", "aaabbb", and "aaabbb".
    We add  before each substring and  after each substring: "aaabbb".
    Since the first two 's overlap, we merge them: "aaabbb".
    Since now the four 's are consecutive, we merge them: "aaabbb".
    """


Prompt:
from typing import Optional
class TreeNode:
    def __init__(val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def mergeTrees(root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
"""
You are given two binary trees root1 and root2.
Imagine that when you put one of them to cover the other, some nodes of the two trees are overlapped while the others are not. You need to merge the two trees into a new binary tree. The merge rule is that if two nodes overlap, then sum node values up as the new value of the merged node. Otherwise, the NOT null node will be used as the node of the new tree.
Return the merged tree.
Note: The merging process must start from the root nodes of both trees.

Example 1:

>>> mergeTrees(root1 = [1,3,2,5], root2 = [2,1,3,null,4,null,7])
>>> [3,4,5,5,4,null,7]

Example 2:

>>> mergeTrees(root1 = [1], root2 = [1,2])
>>> [2,2]
"""


Prompt:
from typing import List
def leastInterval(tasks: List[str], n: int) -> int:
    """
    You are given an array of CPU tasks, each labeled with a letter from A to Z, and a number n. Each CPU interval can be idle or allow the completion of one task. Tasks can be completed in any order, but there's a constraint: there has to be a gap of at least n intervals between two tasks with the same label.
    Return the minimum number of CPU intervals required to complete all tasks.

    Example 1:

    >>> leastInterval(tasks = ["A","A","A","B","B","B"], n = 2)
    >>> 8
    Explanation: A possible sequence is: A -> B -> idle -> A -> B -> idle -> A -> B.
    After completing task A, you must wait two intervals before doing A again. The same applies to task B. In the 3rd interval, neither A nor B can be done, so you idle. By the 4th interval, you can do A again as 2 intervals have passed.

    Example 2:

    >>> leastInterval(tasks = ["A","C","A","B","D","B"], n = 1)
    >>> 6
    Explanation: A possible sequence is: A -> B -> C -> D -> A -> B.
    With a cooling interval of 1, you can repeat a task after just one other task.

    Example 3:

    >>> leastInterval(tasks = ["A","A","A", "B","B","B"], n = 3)
    >>> 10
    Explanation: A possible sequence is: A -> B -> idle -> idle -> A -> B -> idle -> idle -> A -> B.
    There are only two types of tasks, A and B, which need to be separated by 3 intervals. This leads to idling twice between repetitions of these tasks.
    """


Prompt:
from typing import Optional
class TreeNode:
    def __init__(val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def addOneRow(root: Optional[TreeNode], val: int, depth: int) -> Optional[TreeNode]:
"""
Given the root of a binary tree and two integers val and depth, add a row of nodes with value val at the given depth depth.
Note that the root node is at depth 1.
The adding rule is:

Given the integer depth, for each not null tree node cur at the depth depth - 1, create two tree nodes with value val as cur's left subtree root and right subtree root.
cur's original left subtree should be the left subtree of the new left subtree root.
cur's original right subtree should be the right subtree of the new right subtree root.
If depth == 1 that means there is no depth depth - 1 at all, then create a tree node with value val as the new root of the whole original tree, and the original tree is the new root's left subtree.

Example 1:

>>> addOneRow(root = [4,2,6,3,1,5], val = 1, depth = 2)
>>> [4,1,1,2,null,null,6,3,1,5]

Example 2:

>>> addOneRow(root = [4,2,null,3,1], val = 1, depth = 3)
>>> [4,2,null,1,1,3,null,null,1]
"""


Prompt:
from typing import List
def maxDistance(arrays: List[List[int]]) -> int:
    """
    You are given m arrays, where each array is sorted in ascending order.
    You can pick up two integers from two different arrays (each array picks one) and calculate the distance. We define the distance between two integers a and b to be their absolute difference |a - b|.
    Return the maximum distance.

    Example 1:

    >>> maxDistance(arrays = [[1,2,3],[4,5],[1,2,3]])
    >>> 4
    Explanation: One way to reach the maximum distance 4 is to pick 1 in the first or third array and pick 5 in the second array.

    Example 2:

    >>> maxDistance(arrays = [[1],[1]])
    >>> 0
    """


Prompt:
def smallestFactorization(num: int) -> int:
    """
    Given a positive integer num, return the smallest positive integer x whose multiplication of each digit equals num. If there is no answer or the answer is not fit in 32-bit signed integer, return 0.

    Example 1:
    >>> smallestFactorization(num = 48)
    >>> 68
    Example 2:
    >>> smallestFactorization(num = 15)
    >>> 35
    """


Prompt:
from typing import List
def maximumProduct(nums: List[int]) -> int:
    """
    Given an integer array nums, find three numbers whose product is maximum and return the maximum product.

    Example 1:
    >>> maximumProduct(nums = [1,2,3])
    >>> 6
    Example 2:
    >>> maximumProduct(nums = [1,2,3,4])
    >>> 24
    Example 3:
    >>> maximumProduct(nums = [-1,-2,-3])
    >>> -6
    """


Prompt:
def kInversePairs(n: int, k: int) -> int:
    """
    For an integer array nums, an inverse pair is a pair of integers [i, j] where 0 <= i < j < nums.length and nums[i] > nums[j].
    Given two integers n and k, return the number of different arrays consisting of numbers from 1 to n such that there are exactly k inverse pairs. Since the answer can be huge, return it modulo 109 + 7.

    Example 1:

    >>> kInversePairs(n = 3, k = 0)
    >>> 1
    Explanation: Only the array [1,2,3] which consists of numbers from 1 to 3 has exactly 0 inverse pairs.

    Example 2:

    >>> kInversePairs(n = 3, k = 1)
    >>> 2
    Explanation: The array [1,3,2] and [2,1,3] have exactly 1 inverse pair.
    """


Prompt:
from typing import List
def scheduleCourse(courses: List[List[int]]) -> int:
    """
    There are n different online courses numbered from 1 to n. You are given an array courses where courses[i] = [durationi, lastDayi] indicate that the ith course should be taken continuously for durationi days and must be finished before or on lastDayi.
    You will start on the 1st day and you cannot take two or more courses simultaneously.
    Return the maximum number of courses that you can take.

    Example 1:

    >>> scheduleCourse(courses = [[100,200],[200,1300],[1000,1250],[2000,3200]])
    >>> 3
    Explanation:
    There are totally 4 courses, but you can take 3 courses at most:
    First, take the 1st course, it costs 100 days so you will finish it on the 100th day, and ready to take the next course on the 101st day.
    Second, take the 3rd course, it costs 1000 days so you will finish it on the 1100th day, and ready to take the next course on the 1101st day.
    Third, take the 2nd course, it costs 200 days so you will finish it on the 1300th day.
    The 4th course cannot be taken now, since you will finish it on the 3300th day, which exceeds the closed date.

    Example 2:

    >>> scheduleCourse(courses = [[1,2]])
    >>> 1

    Example 3:

    >>> scheduleCourse(courses = [[3,2],[4,3]])
    >>> 0
    """


Prompt:
from typing import List
def smallestRange(nums: List[List[int]]) -> List[int]:
    """
    You have k lists of sorted integers in non-decreasing order. Find the smallest range that includes at least one number from each of the k lists.
    We define the range [a, b] is smaller than range [c, d] if b - a < d - c or a < c if b - a == d - c.

    Example 1:

    >>> smallestRange(nums = [[4,10,15,24,26],[0,9,12,20],[5,18,22,30]])
    >>> [20,24]
    Explanation:
    List 1: [4, 10, 15, 24,26], 24 is in range [20,24].
    List 2: [0, 9, 12, 20], 20 is in range [20,24].
    List 3: [5, 18, 22, 30], 22 is in range [20,24].

    Example 2:

    >>> smallestRange(nums = [[1,2,3],[1,2,3],[1,2,3]])
    >>> [1,1]
    """


Prompt:
def judgeSquareSum(c: int) -> bool:
    """
    Given a non-negative integer c, decide whether there're two integers a and b such that a2 + b2 = c.

    Example 1:

    >>> judgeSquareSum(c = 5)
    >>> true
    Explanation: 1 * 1 + 2 * 2 = 5

    Example 2:

    >>> judgeSquareSum(c = 3)
    >>> false
    """


Prompt:
def findDerangement(n: int) -> int:
    """
    In combinatorial mathematics, a derangement is a permutation of the elements of a set, such that no element appears in its original position.
    You are given an integer n. There is originally an array consisting of n integers from 1 to n in ascending order, return the number of derangements it can generate. Since the answer may be huge, return it modulo 109 + 7.

    Example 1:

    >>> findDerangement(n = 3)
    >>> 2
    Explanation: The original array is [1,2,3]. The two derangements are [2,3,1] and [3,1,2].

    Example 2:

    >>> findDerangement(n = 2)
    >>> 1
    """


Prompt:
from typing import List
def exclusiveTime(n: int, logs: List[str]) -> List[int]:
    """
    On a single-threaded CPU, we execute a program containing n functions. Each function has a unique ID between 0 and n-1.
    Function calls are stored in a call stack: when a function call starts, its ID is pushed onto the stack, and when a function call ends, its ID is popped off the stack. The function whose ID is at the top of the stack is the current function being executed. Each time a function starts or ends, we write a log with the ID, whether it started or ended, and the timestamp.
    You are given a list logs, where logs[i] represents the ith log message formatted as a string "{function_id}:{"start" | "end"}:{timestamp}". For example, "0:start:3" means a function call with function ID 0 started at the beginning of timestamp 3, and "1:end:2" means a function call with function ID 1 ended at the end of timestamp 2. Note that a function can be called multiple times, possibly recursively.
    A function's exclusive time is the sum of execution times for all function calls in the program. For example, if a function is called twice, one call executing for 2 time units and another call executing for 1 time unit, the exclusive time is 2 + 1 = 3.
    Return the exclusive time of each function in an array, where the value at the ith index represents the exclusive time for the function with ID i.

    Example 1:

    >>> exclusiveTime(n = 2, logs = ["0:start:0","1:start:2","1:end:5","0:end:6"])
    >>> [3,4]
    Explanation:
    Function 0 starts at the beginning of time 0, then it executes 2 for units of time and reaches the end of time 1.
    Function 1 starts at the beginning of time 2, executes for 4 units of time, and ends at the end of time 5.
    Function 0 resumes execution at the beginning of time 6 and executes for 1 unit of time.
    So function 0 spends 2 + 1 = 3 units of total time executing, and function 1 spends 4 units of total time executing.

    Example 2:

    >>> exclusiveTime(n = 1, logs = ["0:start:0","0:start:2","0:end:5","0:start:6","0:end:6","0:end:7"])
    >>> [8]
    Explanation:
    Function 0 starts at the beginning of time 0, executes for 2 units of time, and recursively calls itself.
    Function 0 (recursive call) starts at the beginning of time 2 and executes for 4 units of time.
    Function 0 (initial call) resumes execution then immediately calls itself again.
    Function 0 (2nd recursive call) starts at the beginning of time 6 and executes for 1 unit of time.
    Function 0 (initial call) resumes execution at the beginning of time 7 and executes for 1 unit of time.
    So function 0 spends 2 + 4 + 1 + 1 = 8 units of total time executing.

    Example 3:

    >>> exclusiveTime(n = 2, logs = ["0:start:0","0:start:2","0:end:5","1:start:6","1:end:6","0:end:7"])
    >>> [7,1]
    Explanation:
    Function 0 starts at the beginning of time 0, executes for 2 units of time, and recursively calls itself.
    Function 0 (recursive call) starts at the beginning of time 2 and executes for 4 units of time.
    Function 0 (initial call) resumes execution then immediately calls function 1.
    Function 1 starts at the beginning of time 6, executes 1 unit of time, and ends at the end of time 6.
    Function 0 resumes execution at the beginning of time 6 and executes for 2 units of time.
    So function 0 spends 2 + 4 + 1 = 7 units of total time executing, and function 1 spends 1 unit of total time executing.
    """


Prompt:
from typing import List, Optional
class TreeNode:
    def __init__(val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def averageOfLevels(root: Optional[TreeNode]) -> List[float]:
"""
Given the root of a binary tree, return the average value of the nodes on each level in the form of an array. Answers within 10-5 of the actual answer will be accepted.

Example 1:

>>> averageOfLevels(root = [3,9,20,null,null,15,7])
>>> [3.00000,14.50000,11.00000]
Explanation: The average value of nodes on level 0 is 3, on level 1 is 14.5, and on level 2 is 11.
Hence return [3, 14.5, 11].

Example 2:

>>> averageOfLevels(root = [3,9,20,15,7])
>>> [3.00000,14.50000,11.00000]
"""


Prompt:
from typing import List
def shoppingOffers(price: List[int], special: List[List[int]], needs: List[int]) -> int:
    """
    In LeetCode Store, there are n items to sell. Each item has a price. However, there are some special offers, and a special offer consists of one or more different kinds of items with a sale price.
    You are given an integer array price where price[i] is the price of the ith item, and an integer array needs where needs[i] is the number of pieces of the ith item you want to buy.
    You are also given an array special where special[i] is of size n + 1 where special[i][j] is the number of pieces of the jth item in the ith offer and special[i][n] (i.e., the last integer in the array) is the price of the ith offer.
    Return the lowest price you have to pay for exactly certain items as given, where you could make optimal use of the special offers. You are not allowed to buy more items than you want, even if that would lower the overall price. You could use any of the special offers as many times as you want.

    Example 1:

    >>> shoppingOffers(price = [2,5], special = [[3,0,5],[1,2,10]], needs = [3,2])
    >>> 14
    Explanation: There are two kinds of items, A and B. Their prices are $2 and $5 respectively.
    In special offer 1, you can pay $5 for 3A and 0B
    In special offer 2, you can pay $10 for 1A and 2B.
    You need to buy 3A and 2B, so you may pay $10 for 1A and 2B (special offer #2), and $4 for 2A.

    Example 2:

    >>> shoppingOffers(price = [2,3,4], special = [[1,1,0,4],[2,2,1,9]], needs = [1,2,1])
    >>> 11
    Explanation: The price of A is $2, and $3 for B, $4 for C.
    You may pay $4 for 1A and 1B, and $9 for 2A ,2B and 1C.
    You need to buy 1A ,2B and 1C, so you may pay $4 for 1A and 1B (special offer #1), and $3 for 1B, $4 for 1C.
    You cannot add more items, though only $9 for 2A ,2B and 1C.
    """


Prompt:
def numDecodings(s: str) -> int:
    """
    A message containing letters from A-Z can be encoded into numbers using the following mapping:

    'A' -> "1"
    'B' -> "2"
    ...
    'Z' -> "26"

    To decode an encoded message, all the digits must be grouped then mapped back into letters using the reverse of the mapping above (there may be multiple ways). For example, "11106" can be mapped into:

    "AAJF" with the grouping (1 1 10 6)
    "KJF" with the grouping (11 10 6)

    Note that the grouping (1 11 06) is invalid because "06" cannot be mapped into 'F' since "6" is different from "06".
    In addition to the mapping above, an encoded message may contain the '*' character, which can represent any digit from '1' to '9' ('0' is excluded). For example, the encoded message "1*" may represent any of the encoded messages "11", "12", "13", "14", "15", "16", "17", "18", or "19". Decoding "1*" is equivalent to decoding any of the encoded messages it can represent.
    Given a string s consisting of digits and '*' characters, return the number of ways to decode it.
    Since the answer may be very large, return it modulo 109 + 7.

    Example 1:

    >>> numDecodings(s = "*")
    >>> 9
    Explanation: The encoded message can represent any of the encoded messages "1", "2", "3", "4", "5", "6", "7", "8", or "9".
    Each of these can be decoded to the strings "A", "B", "C", "D", "E", "F", "G", "H", and "I" respectively.
    Hence, there are a total of 9 ways to decode "*".

    Example 2:

    >>> numDecodings(s = "1*")
    >>> 18
    Explanation: The encoded message can represent any of the encoded messages "11", "12", "13", "14", "15", "16", "17", "18", or "19".
    Each of these encoded messages have 2 ways to be decoded (e.g. "11" can be decoded to "AA" or "K").
    Hence, there are a total of 9 * 2 = 18 ways to decode "1*".

    Example 3:

    >>> numDecodings(s = "2*")
    >>> 15
    Explanation: The encoded message can represent any of the encoded messages "21", "22", "23", "24", "25", "26", "27", "28", or "29".
    "21", "22", "23", "24", "25", and "26" have 2 ways of being decoded, but "27", "28", and "29" only have 1 way.
    Hence, there are a total of (6 * 2) + (3 * 1) = 12 + 3 = 15 ways to decode "2*".
    """


Prompt:
def solveEquation(equation: str) -> str:
    """
    Solve a given equation and return the value of 'x' in the form of a string "x=#value". The equation contains only '+', '-' operation, the variable 'x' and its coefficient. You should return "No solution" if there is no solution for the equation, or "Infinite solutions" if there are infinite solutions for the equation.
    If there is exactly one solution for the equation, we ensure that the value of 'x' is an integer.

    Example 1:

    >>> solveEquation(equation = "x+5-3+x=6+x-2")
    >>> "x=2"

    Example 2:

    >>> solveEquation(equation = "x=x")
    >>> "Infinite solutions"

    Example 3:

    >>> solveEquation(equation = "2x=x")
    >>> "x=0"
    """


Prompt:
from typing import Any, List
def findMaxAverage(nums: List[int], k: int) -> float:
    """
    You are given an integer array nums consisting of n elements, and an integer k.
    Find a contiguous subarray whose length is equal to k that has the maximum average value and return this value. Any answer with a calculation error less than 10-5 will be accepted.

    Example 1:

    >>> findMaxAverage(nums = [1,12,-5,-6,50,3], k = 4)
    >>> 12.75000
    Explanation: Maximum average is (12 - 5 - 6 + 50) / 4 = 51 / 4 = 12.75

    Example 2:

    >>> findMaxAverage(nums = [5], k = 1)
    >>> 5.00000
    """


Prompt:
from typing import Any, List
def findMaxAverage(nums: List[int], k: int) -> float:
    """
    You are given an integer array nums consisting of n elements, and an integer k.
    Find a contiguous subarray whose length is greater than or equal to k that has the maximum average value and return this value. Any answer with a calculation error less than 10-5 will be accepted.

    Example 1:

    >>> findMaxAverage(nums = [1,12,-5,-6,50,3], k = 4)
    >>> 12.75000
    Explanation:
    - When the length is 4, averages are [0.5, 12.75, 10.5] and the maximum average is 12.75
    - When the length is 5, averages are [10.4, 10.8] and the maximum average is 10.8
    - When the length is 6, averages are [9.16667] and the maximum average is 9.16667
    The maximum average is when we choose a subarray of length 4 (i.e., the sub array [12, -5, -6, 50]) which has the max average 12.75, so we return 12.75
    Note that we do not consider the subarrays of length < 4.

    Example 2:

    >>> findMaxAverage(nums = [5], k = 1)
    >>> 5.00000
    """


Prompt:
from typing import List
def findErrorNums(nums: List[int]) -> List[int]:
    """
    You have a set of integers s, which originally contains all the numbers from 1 to n. Unfortunately, due to some error, one of the numbers in s got duplicated to another number in the set, which results in repetition of one number and loss of another number.
    You are given an integer array nums representing the data status of this set after the error.
    Find the number that occurs twice and the number that is missing and return them in the form of an array.

    Example 1:
    >>> findErrorNums(nums = [1,2,2,4])
    >>> [2,3]
    Example 2:
    >>> findErrorNums(nums = [1,1])
    >>> [1,2]
    """


Prompt:
from typing import List
def findLongestChain(pairs: List[List[int]]) -> int:
    """
    You are given an array of n pairs pairs where pairs[i] = [lefti, righti] and lefti < righti.
    A pair p2 = [c, d] follows a pair p1 = [a, b] if b < c. A chain of pairs can be formed in this fashion.
    Return the length longest chain which can be formed.
    You do not need to use up all the given intervals. You can select pairs in any order.

    Example 1:

    >>> findLongestChain(pairs = [[1,2],[2,3],[3,4]])
    >>> 2
    Explanation: The longest chain is [1,2] -> [3,4].

    Example 2:

    >>> findLongestChain(pairs = [[1,2],[7,8],[4,5]])
    >>> 3
    Explanation: The longest chain is [1,2] -> [4,5] -> [7,8].
    """


Prompt:
def countSubstrings(s: str) -> int:
    """
    Given a string s, return the number of palindromic substrings in it.
    A string is a palindrome when it reads the same backward as forward.
    A substring is a contiguous sequence of characters within the string.

    Example 1:

    >>> countSubstrings(s = "abc")
    >>> 3
    Explanation: Three palindromic strings: "a", "b", "c".

    Example 2:

    >>> countSubstrings(s = "aaa")
    >>> 6
    Explanation: Six palindromic strings: "a", "a", "a", "aa", "aa", "aaa".
    """


Prompt:
from typing import List
def replaceWords(dictionary: List[str], sentence: str) -> str:
    """
    In English, we have a concept called root, which can be followed by some other word to form another longer word - let's call this word derivative. For example, when the root "help" is followed by the word "ful", we can form a derivative "helpful".
    Given a dictionary consisting of many roots and a sentence consisting of words separated by spaces, replace all the derivatives in the sentence with the root forming it. If a derivative can be replaced by more than one root, replace it with the root that has the shortest length.
    Return the sentence after the replacement.

    Example 1:

    >>> replaceWords(dictionary = ["cat","bat","rat"], sentence = "the cattle was rattled by the battery")
    >>> "the cat was rat by the bat"

    Example 2:

    >>> replaceWords(dictionary = ["a","b","c"], sentence = "aadsfasf absbs bbab cadsfafs")
    >>> "a a b c"
    """


Prompt:
def predictPartyVictory(senate: str) -> str:
    """
    In the world of Dota2, there are two parties: the Radiant and the Dire.
    The Dota2 senate consists of senators coming from two parties. Now the Senate wants to decide on a change in the Dota2 game. The voting for this change is a round-based procedure. In each round, each senator can exercise one of the two rights:

    Ban one senator's right: A senator can make another senator lose all his rights in this and all the following rounds.
    Announce the victory: If this senator found the senators who still have rights to vote are all from the same party, he can announce the victory and decide on the change in the game.

    Given a string senate representing each senator's party belonging. The character 'R' and 'D' represent the Radiant party and the Dire party. Then if there are n senators, the size of the given string will be n.
    The round-based procedure starts from the first senator to the last senator in the given order. This procedure will last until the end of voting. All the senators who have lost their rights will be skipped during the procedure.
    Suppose every senator is smart enough and will play the best strategy for his own party. Predict which party will finally announce the victory and change the Dota2 game. The output should be "Radiant" or "Dire".

    Example 1:

    >>> predictPartyVictory(senate = "RD")
    >>> "Radiant"
    Explanation:
    The first senator comes from Radiant and he can just ban the next senator's right in round 1.
    And the second senator can't exercise any rights anymore since his right has been banned.
    And in round 2, the first senator can just announce the victory since he is the only guy in the senate who can vote.

    Example 2:

    >>> predictPartyVictory(senate = "RDD")
    >>> "Dire"
    Explanation:
    The first senator comes from Radiant and he can just ban the next senator's right in round 1.
    And the second senator can't exercise any rights anymore since his right has been banned.
    And the third senator comes from Dire and he can ban the first senator's right in round 1.
    And in round 2, the third senator can just announce the victory since he is the only guy in the senate who can vote.
    """


Prompt:
def minSteps(n: int) -> int:
    """
    There is only one character 'A' on the screen of a notepad. You can perform one of two operations on this notepad for each step:

    Copy All: You can copy all the characters present on the screen (a partial copy is not allowed).
    Paste: You can paste the characters which are copied last time.

    Given an integer n, return the minimum number of operations to get the character 'A' exactly n times on the screen.

    Example 1:

    >>> minSteps(n = 3)
    >>> 3
    Explanation: Initially, we have one character 'A'.
    In step 1, we use Copy All operation.
    In step 2, we use Paste operation to get 'AA'.
    In step 3, we use Paste operation to get 'AAA'.

    Example 2:

    >>> minSteps(n = 1)
    >>> 0
    """


Prompt:
def maxA(n: int) -> int:
    """
    Imagine you have a special keyboard with the following keys:

    A: Print one 'A' on the screen.
    Ctrl-A: Select the whole screen.
    Ctrl-C: Copy selection to buffer.
    Ctrl-V: Print buffer on screen appending it after what has already been printed.

    Given an integer n, return the maximum number of 'A' you can print on the screen with at most n presses on the keys.

    Example 1:

    >>> maxA(n = 3)
    >>> 3
    Explanation: We can at most get 3 A's on screen by pressing the following key sequence:
    A, A, A

    Example 2:

    >>> maxA(n = 7)
    >>> 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
    """


Prompt:
from typing import Optional
class TreeNode:
    def __init__(val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def findTarget(root: Optional[TreeNode], k: int) -> bool:
"""
Given the root of a binary search tree and an integer k, return true if there exist two elements in the BST such that their sum is equal to k, or false otherwise.

Example 1:

>>> findTarget(root = [5,3,6,2,4,null,7], k = 9)
>>> true

Example 2:

>>> findTarget(root = [5,3,6,2,4,null,7], k = 28)
>>> false
"""


Prompt:
from typing import List, Optional
class TreeNode:
    def __init__(val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def constructMaximumBinaryTree(nums: List[int]) -> Optional[TreeNode]:
"""
You are given an integer array nums with no duplicates. A maximum binary tree can be built recursively from nums using the following algorithm:

Create a root node whose value is the maximum value in nums.
Recursively build the left subtree on the subarray prefix to the left of the maximum value.
Recursively build the right subtree on the subarray suffix to the right of the maximum value.

Return the maximum binary tree built from nums.

Example 1:

>>> constructMaximumBinaryTree(nums = [3,2,1,6,0,5])
>>> [6,3,5,null,2,0,null,null,1]
Explanation: The recursive calls are as follow:
- The largest value in [3,2,1,6,0,5] is 6. Left prefix is [3,2,1] and right suffix is [0,5].
    - The largest value in [3,2,1] is 3. Left prefix is [] and right suffix is [2,1].
        - Empty array, so no child.
        - The largest value in [2,1] is 2. Left prefix is [] and right suffix is [1].
            - Empty array, so no child.
            - Only one element, so child is a node with value 1.
    - The largest value in [0,5] is 5. Left prefix is [0] and right suffix is [].
        - Only one element, so child is a node with value 0.
        - Empty array, so no child.

Example 2:

>>> constructMaximumBinaryTree(nums = [3,2,1])
>>> [3,null,2,null,1]
"""


Prompt:
from typing import Any, List, Optional
class TreeNode:
    def __init__(val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def printTree(root: Optional[TreeNode]) -> List[List[str]]:
"""
Given the root of a binary tree, construct a 0-indexed m x n string matrix res that represents a formatted layout of the tree. The formatted layout matrix should be constructed using the following rules:

The height of the tree is height and the number of rows m should be equal to height + 1.
The number of columns n should be equal to 2height+1 - 1.
Place the root node in the middle of the top row (more formally, at location res[0][(n-1)/2]).
For each node that has been placed in the matrix at position res[r][c], place its left child at res[r+1][c-2height-r-1] and its right child at res[r+1][c+2height-r-1].
Continue this process until all the nodes in the tree have been placed.
Any empty cells should contain the empty string "".

Return the constructed matrix res.

Example 1:

>>> printTree(root = [1,2])
>>>
[["","1",""],
 ["2","",""]]

Example 2:

>>> printTree(root = [1,2,3,null,4])
>>>
[["","","","1","","",""],
 ["","2","","","","3",""],
 ["","","4","","","",""]]
"""


Prompt:
from typing import List
def cheapestJump(coins: List[int], maxJump: int) -> List[int]:
    """
    You are given an integer array coins (1-indexed) of length n and an integer maxJump. You can jump to any index i of the array coins if coins[i] != -1 and you have to pay coins[i] when you visit index i. In addition to that, if you are currently at index i, you can only jump to any index i + k where i + k <= n and k is a value in the range [1, maxJump].
    You are initially positioned at index 1 (coins[1] is not -1). You want to find the path that reaches index n with the minimum cost.
    Return an integer array of the indices that you will visit in order so that you can reach index n with the minimum cost. If there are multiple paths with the same cost, return the lexicographically smallest such path. If it is not possible to reach index n, return an empty array.
    A path p1 = [Pa1, Pa2, ..., Pax] of length x is lexicographically smaller than p2 = [Pb1, Pb2, ..., Pbx] of length y, if and only if at the first j where Paj and Pbj differ, Paj < Pbj; when no such j exists, then x < y.

    Example 1:
    >>> cheapestJump(coins = [1,2,4,-1,2], maxJump = 2)
    >>> [1,3,5]
    Example 2:
    >>> cheapestJump(coins = [1,2,4,-1,2], maxJump = 1)
    >>> []
    """


Prompt:
def judgeCircle(moves: str) -> bool:
    """
    There is a robot starting at the position (0, 0), the origin, on a 2D plane. Given a sequence of its moves, judge if this robot ends up at (0, 0) after it completes its moves.
    You are given a string moves that represents the move sequence of the robot where moves[i] represents its ith move. Valid moves are 'R' (right), 'L' (left), 'U' (up), and 'D' (down).
    Return true if the robot returns to the origin after it finishes all of its moves, or false otherwise.
    Note: The way that the robot is "facing" is irrelevant. 'R' will always make the robot move to the right once, 'L' will always make it move left, etc. Also, assume that the magnitude of the robot's movement is the same for each move.

    Example 1:

    >>> judgeCircle(moves = "UD")
    >>> true
    Explanation: The robot moves up once, and then down once. All moves have the same magnitude, so it ended up at the origin where it started. Therefore, we return true.

    Example 2:

    >>> judgeCircle(moves = "LL")
    >>> false
    Explanation: The robot moves left twice. It ends up two "moves" to the left of the origin. We return false because it is not at the origin at the end of its moves.
    """


Prompt:
from typing import List
def findClosestElements(arr: List[int], k: int, x: int) -> List[int]:
    """
    Given a sorted integer array arr, two integers k and x, return the k closest integers to x in the array. The result should also be sorted in ascending order.
    An integer a is closer to x than an integer b if:

    |a - x| < |b - x|, or
    |a - x| == |b - x| and a < b

    Example 1:

    >>> findClosestElements(arr = [1,2,3,4,5], k = 4, x = 3)
    >>> [1,2,3,4]

    Example 2:

    >>> findClosestElements(arr = [1,1,2,3,4,5], k = 4, x = -1)
    >>> [1,1,2,3]
    """


Prompt:
from typing import List
def isPossible(nums: List[int]) -> bool:
    """
    You are given an integer array nums that is sorted in non-decreasing order.
    Determine if it is possible to split nums into one or more subsequences such that both of the following conditions are true:

    Each subsequence is a consecutive increasing sequence (i.e. each integer is exactly one more than the previous integer).
    All subsequences have a length of 3 or more.

    Return true if you can split nums according to the above conditions, or false otherwise.
    A subsequence of an array is a new array that is formed from the original array by deleting some (can be none) of the elements without disturbing the relative positions of the remaining elements. (i.e., [1,3,5] is a subsequence of [1,2,3,4,5] while [1,3,2] is not).

    Example 1:

    >>> isPossible(nums = [1,2,3,3,4,5])
    >>> true
    Explanation: nums can be split into the following subsequences:
    [1,2,3,3,4,5] --> 1, 2, 3
    [1,2,3,3,4,5] --> 3, 4, 5

    Example 2:

    >>> isPossible(nums = [1,2,3,3,4,4,5,5])
    >>> true
    Explanation: nums can be split into the following subsequences:
    [1,2,3,3,4,4,5,5] --> 1, 2, 3, 4, 5
    [1,2,3,3,4,4,5,5] --> 3, 4, 5

    Example 3:

    >>> isPossible(nums = [1,2,3,4,4,5])
    >>> false
    Explanation: It is impossible to split nums into consecutive increasing subsequences of length 3 or more.
    """


Prompt:
def newInteger(n: int) -> int:
    """
    Start from integer 1, remove any integer that contains 9 such as 9, 19, 29...
    Now, you will have a new integer sequence [1, 2, 3, 4, 5, 6, 7, 8, 10, 11, ...].
    Given an integer n, return the nth (1-indexed) integer in the new sequence.

    Example 1:

    >>> newInteger(n = 9)
    >>> 10

    Example 2:

    >>> newInteger(n = 10)
    >>> 11
    """


Prompt:
from typing import List
def imageSmoother(img: List[List[int]]) -> List[List[int]]:
    """
    An image smoother is a filter of the size 3 x 3 that can be applied to each cell of an image by rounding down the average of the cell and the eight surrounding cells (i.e., the average of the nine cells in the blue smoother). If one or more of the surrounding cells of a cell is not present, we do not consider it in the average (i.e., the average of the four cells in the red smoother).

    Given an m x n integer matrix img representing the grayscale of an image, return the image after applying the smoother on each cell of it.

    Example 1:

    >>> imageSmoother(img = [[1,1,1],[1,0,1],[1,1,1]])
    >>> [[0,0,0],[0,0,0],[0,0,0]]
    Explanation:
    For the points (0,0), (0,2), (2,0), (2,2): floor(3/4) = floor(0.75) = 0
    For the points (0,1), (1,0), (1,2), (2,1): floor(5/6) = floor(0.83333333) = 0
    For the point (1,1): floor(8/9) = floor(0.88888889) = 0

    Example 2:

    >>> imageSmoother(img = [[100,200,100],[200,50,200],[100,200,100]])
    >>> [[137,141,137],[141,138,141],[137,141,137]]
    Explanation:
    For the points (0,0), (0,2), (2,0), (2,2): floor((100+200+200+50)/4) = floor(137.5) = 137
    For the points (0,1), (1,0), (1,2), (2,1): floor((200+200+50+200+100+100)/6) = floor(141.666667) = 141
    For the point (1,1): floor((50+200+200+200+200+100+100+100+100)/9) = floor(138.888889) = 138
    """


Prompt:
from typing import Optional
class TreeNode:
    def __init__(val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def widthOfBinaryTree(root: Optional[TreeNode]) -> int:
"""
Given the root of a binary tree, return the maximum width of the given tree.
The maximum width of a tree is the maximum width among all levels.
The width of one level is defined as the length between the end-nodes (the leftmost and rightmost non-null nodes), where the null nodes between the end-nodes that would be present in a complete binary tree extending down to that level are also counted into the length calculation.
It is guaranteed that the answer will in the range of a 32-bit signed integer.

Example 1:

>>> widthOfBinaryTree(root = [1,3,2,5,3,null,9])
>>> 4
Explanation: The maximum width exists in the third level with length 4 (5,3,null,9).

Example 2:

>>> widthOfBinaryTree(root = [1,3,2,5,null,null,9,6,null,7])
>>> 7
Explanation: The maximum width exists in the fourth level with length 7 (6,null,null,null,null,null,7).

Example 3:

>>> widthOfBinaryTree(root = [1,3,2,5])
>>> 2
Explanation: The maximum width exists in the second level with length 2 (3,2).
"""


Prompt:
from typing import Optional
class TreeNode:
    def __init__(val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def checkEqualTree(root: Optional[TreeNode]) -> bool:
"""
Given the root of a binary tree, return true if you can partition the tree into two trees with equal sums of values after removing exactly one edge on the original tree.

Example 1:

>>> checkEqualTree(root = [5,10,10,null,null,2,3])
>>> true

Example 2:

>>> checkEqualTree(root = [1,2,10,null,null,2,20])
>>> false
Explanation: You cannot split the tree into two trees with equal sums after removing exactly one edge on the tree.
"""


Prompt:
def strangePrinter(s: str) -> int:
    """
    There is a strange printer with the following two special properties:

    The printer can only print a sequence of the same character each time.
    At each turn, the printer can print new characters starting from and ending at any place and will cover the original existing characters.

    Given a string s, return the minimum number of turns the printer needed to print it.

    Example 1:

    >>> strangePrinter(s = "aaabbb")
    >>> 2
    Explanation: Print "aaa" first and then print "bbb".

    Example 2:

    >>> strangePrinter(s = "aba")
    >>> 2
    Explanation: Print "aaa" first and then print "b" from the second place of the string, which will cover the existing character 'a'.
    """


Prompt:
from typing import List
def checkPossibility(nums: List[int]) -> bool:
    """
    Given an array nums with n integers, your task is to check if it could become non-decreasing by modifying at most one element.
    We define an array is non-decreasing if nums[i] <= nums[i + 1] holds for every i (0-based) such that (0 <= i <= n - 2).

    Example 1:

    >>> checkPossibility(nums = [4,2,3])
    >>> true
    Explanation: You could modify the first 4 to 1 to get a non-decreasing array.

    Example 2:

    >>> checkPossibility(nums = [4,2,1])
    >>> false
    Explanation: You cannot get a non-decreasing array by modifying at most one element.
    """


Prompt:
from typing import List
def pathSum(nums: List[int]) -> int:
    """
    If the depth of a tree is smaller than 5, then this tree can be represented by an array of three-digit integers. You are given an ascending array nums consisting of three-digit integers representing a binary tree with a depth smaller than 5, where for each integer:

    The hundreds digit represents the depth d of this node, where 1 <= d <= 4.
    The tens digit represents the position p of this node within its level, where 1 <= p <= 8, corresponding to its position in a full binary tree.
    The units digit represents the value v of this node, where 0 <= v <= 9.

    Return the sum of all paths from the root towards the leaves.
    It is guaranteed that the given array represents a valid connected binary tree.

    Example 1:

    >>> pathSum(nums = [113,215,221])
    >>> 12
    Explanation:
    The tree that the list represents is shown.
    The path sum is (3 + 5) + (3 + 1) = 12.

    Example 2:

    >>> pathSum(nums = [113,221])
    >>> 4
    Explanation:
    The tree that the list represents is shown.
    The path sum is (3 + 1) = 4.
    """


Prompt:
from typing import List
def constructArray(n: int, k: int) -> List[int]:
    """
    Given two integers n and k, construct a list answer that contains n different positive integers ranging from 1 to n and obeys the following requirement:

    Suppose this list is answer = [a1, a2, a3, ... , an], then the list [|a1 - a2|, |a2 - a3|, |a3 - a4|, ... , |an-1 - an|] has exactly k distinct integers.

    Return the list answer. If there multiple valid answers, return any of them.

    Example 1:

    >>> constructArray(n = 3, k = 1)
    >>> [1,2,3]
    Explanation: The [1,2,3] has three different positive integers ranging from 1 to 3, and the [1,1] has exactly 1 distinct integer: 1

    Example 2:

    >>> constructArray(n = 3, k = 2)
    >>> [1,3,2]
    Explanation: The [1,3,2] has three different positive integers ranging from 1 to 3, and the [2,1] has exactly 2 distinct integers: 1 and 2.
    """


Prompt:
def findKthNumber(m: int, n: int, k: int) -> int:
    """
    Nearly everyone has used the Multiplication Table. The multiplication table of size m x n is an integer matrix mat where mat[i][j] == i * j (1-indexed).
    Given three integers m, n, and k, return the kth smallest element in the m x n multiplication table.

    Example 1:

    >>> findKthNumber(m = 3, n = 3, k = 5)
    >>> 3
    Explanation: The 5th smallest number is 3.

    Example 2:

    >>> findKthNumber(m = 2, n = 3, k = 6)
    >>> 6
    Explanation: The 6th smallest number is 6.
    """


Prompt:
from typing import Optional
class TreeNode:
    def __init__(val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def trimBST(root: Optional[TreeNode], low: int, high: int) -> Optional[TreeNode]:
"""
Given the root of a binary search tree and the lowest and highest boundaries as low and high, trim the tree so that all its elements lies in [low, high]. Trimming the tree should not change the relative structure of the elements that will remain in the tree (i.e., any node's descendant should remain a descendant). It can be proven that there is a unique answer.
Return the root of the trimmed binary search tree. Note that the root may change depending on the given bounds.

Example 1:

>>> trimBST(root = [1,0,2], low = 1, high = 2)
>>> [1,null,2]

Example 2:

>>> trimBST(root = [3,0,4,null,2,null,null,1], low = 1, high = 3)
>>> [3,2,null,1]
"""


Prompt:
def maximumSwap(num: int) -> int:
    """
    You are given an integer num. You can swap two digits at most once to get the maximum valued number.
    Return the maximum valued number you can get.

    Example 1:

    >>> maximumSwap(num = 2736)
    >>> 7236
    Explanation: Swap the number 2 and the number 7.

    Example 2:

    >>> maximumSwap(num = 9973)
    >>> 9973
    Explanation: No swap.
    """


Prompt:
from typing import Optional
class TreeNode:
    def __init__(val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def findSecondMinimumValue(root: Optional[TreeNode]) -> int:
"""
Given a non-empty special binary tree consisting of nodes with the non-negative value, where each node in this tree has exactly two or zero sub-node. If the node has two sub-nodes, then this node's value is the smaller value among its two sub-nodes. More formally, the property root.val = min(root.left.val, root.right.val) always holds.
Given such a binary tree, you need to output the second minimum value in the set made of all the nodes' value in the whole tree.
If no such second minimum value exists, output -1 instead.

Example 1:

>>> findSecondMinimumValue(root = [2,2,5,null,null,5,7])
>>> 5
Explanation: The smallest value is 2, the second smallest value is 5.

Example 2:

>>> findSecondMinimumValue(root = [2,2,2])
>>> -1
Explanation: The smallest value is 2, but there isn't any second smallest value.
"""


Prompt:
def flipLights(n: int, presses: int) -> int:
    """
    There is a room with n bulbs labeled from 1 to n that all are turned on initially, and four buttons on the wall. Each of the four buttons has a different functionality where:

    Button 1: Flips the status of all the bulbs.
    Button 2: Flips the status of all the bulbs with even labels (i.e., 2, 4, ...).
    Button 3: Flips the status of all the bulbs with odd labels (i.e., 1, 3, ...).
    Button 4: Flips the status of all the bulbs with a label j = 3k + 1 where k = 0, 1, 2, ... (i.e., 1, 4, 7, 10, ...).

    You must make exactly presses button presses in total. For each press, you may pick any of the four buttons to press.
    Given the two integers n and presses, return the number of different possible statuses after performing all presses button presses.

    Example 1:

    >>> flipLights(n = 1, presses = 1)
    >>> 2
    Explanation: Status can be:
    - [off] by pressing button 1
    - [on] by pressing button 2

    Example 2:

    >>> flipLights(n = 2, presses = 1)
    >>> 3
    Explanation: Status can be:
    - [off, off] by pressing button 1
    - [on, off] by pressing button 2
    - [off, on] by pressing button 3

    Example 3:

    >>> flipLights(n = 3, presses = 1)
    >>> 4
    Explanation: Status can be:
    - [off, off, off] by pressing button 1
    - [off, on, off] by pressing button 2
    - [on, off, on] by pressing button 3
    - [off, on, on] by pressing button 4
    """


Prompt:
from typing import List
def findNumberOfLIS(nums: List[int]) -> int:
    """
    Given an integer array nums, return the number of longest increasing subsequences.
    Notice that the sequence has to be strictly increasing.

    Example 1:

    >>> findNumberOfLIS(nums = [1,3,5,4,7])
    >>> 2
    Explanation: The two longest increasing subsequences are [1, 3, 4, 7] and [1, 3, 5, 7].

    Example 2:

    >>> findNumberOfLIS(nums = [2,2,2,2,2])
    >>> 5
    Explanation: The length of the longest increasing subsequence is 1, and there are 5 increasing subsequences of length 1, so output 5.
    """


Prompt:
from typing import List
def findLengthOfLCIS(nums: List[int]) -> int:
    """
    Given an unsorted array of integers nums, return the length of the longest continuous increasing subsequence (i.e. subarray). The subsequence must be strictly increasing.
    A continuous increasing subsequence is defined by two indices l and r (l < r) such that it is [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] and for each l <= i < r, nums[i] < nums[i + 1].

    Example 1:

    >>> findLengthOfLCIS(nums = [1,3,5,4,7])
    >>> 3
    Explanation: The longest continuous increasing subsequence is [1,3,5] with length 3.
    Even though [1,3,5,7] is an increasing subsequence, it is not continuous as elements 5 and 7 are separated by element
    4.

    Example 2:

    >>> findLengthOfLCIS(nums = [2,2,2,2,2])
    >>> 1
    Explanation: The longest continuous increasing subsequence is [2] with length 1. Note that it must be strictly
    increasing.
    """


Prompt:
from typing import List
def cutOffTree(forest: List[List[int]]) -> int:
    """
    You are asked to cut off all the trees in a forest for a golf event. The forest is represented as an m x n matrix. In this matrix:

    0 means the cell cannot be walked through.
    1 represents an empty cell that can be walked through.
    A number greater than 1 represents a tree in a cell that can be walked through, and this number is the tree's height.

    In one step, you can walk in any of the four directions: north, east, south, and west. If you are standing in a cell with a tree, you can choose whether to cut it off.
    You must cut off the trees in order from shortest to tallest. When you cut off a tree, the value at its cell becomes 1 (an empty cell).
    Starting from the point (0, 0), return the minimum steps you need to walk to cut off all the trees. If you cannot cut off all the trees, return -1.
    Note: The input is generated such that no two trees have the same height, and there is at least one tree needs to be cut off.

    Example 1:

    >>> cutOffTree(forest = [[1,2,3],[0,0,4],[7,6,5]])
    >>> 6
    Explanation: Following the path above allows you to cut off the trees from shortest to tallest in 6 steps.

    Example 2:

    >>> cutOffTree(forest = [[1,2,3],[0,0,0],[7,6,5]])
    >>> -1
    Explanation: The trees in the bottom row cannot be accessed as the middle row is blocked.

    Example 3:

    >>> cutOffTree(forest = [[2,3,4],[0,0,5],[8,7,6]])
    >>> 6
    Explanation: You can follow the same path as Example 1 to cut off all the trees.
    Note that you can cut off the first tree at (0, 0) before making any steps.
    """


Prompt:
from typing import Any
def checkValidString(s: str) -> bool:
    """
    Given a string s containing only three types of characters: '(', ')' and '*', return true if s is valid.
    The following rules define a valid string:

    Any left parenthesis '(' must have a corresponding right parenthesis ')'.
    Any right parenthesis ')' must have a corresponding left parenthesis '('.
    Left parenthesis '(' must go before the corresponding right parenthesis ')'.
    '*' could be treated as a single right parenthesis ')' or a single left parenthesis '(' or an empty string "".

    Example 1:
    >>> checkValidString(s = "()")
    >>> true
    Example 2:
    >>> checkValidString(s = "(*)")
    >>> true
    Example 3:
    >>> checkValidString(s = "(*))")
    >>> true
    """


Prompt:
from typing import List
def judgePoint24(cards: List[int]) -> bool:
    """
    You are given an integer array cards of length 4. You have four cards, each containing a number in the range [1, 9]. You should arrange the numbers on these cards in a mathematical expression using the operators ['+', '-', '*', '/'] and the parentheses '(' and ')' to get the value 24.
    You are restricted with the following rules:

    The division operator '/' represents real division, not integer division.

    For example, 4 / (1 - 2 / 3) = 4 / (1 / 3) = 12.

    Every operation done is between two numbers. In particular, we cannot use '-' as a unary operator.

    For example, if cards = [1, 1, 1, 1], the expression "-1 - 1 - 1 - 1" is not allowed.

    You cannot concatenate numbers together

    For example, if cards = [1, 2, 1, 2], the expression "12 + 12" is not valid.

    Return true if you can get such expression that evaluates to 24, and false otherwise.

    Example 1:

    >>> judgePoint24(cards = [4,1,8,7])
    >>> true
    Explanation: (8-4) * (7-1) = 24

    Example 2:

    >>> judgePoint24(cards = [1,2,1,2])
    >>> false
    """


Prompt:
def validPalindrome(s: str) -> bool:
    """
    Given a string s, return true if the s can be palindrome after deleting at most one character from it.

    Example 1:

    >>> validPalindrome(s = "aba")
    >>> true

    Example 2:

    >>> validPalindrome(s = "abca")
    >>> true
    Explanation: You could delete the character 'c'.

    Example 3:

    >>> validPalindrome(s = "abc")
    >>> false
    """


Prompt:
def nextClosestTime(time: str) -> str:
    """
    Given a time represented in the format "HH:MM", form the next closest time by reusing the current digits. There is no limit on how many times a digit can be reused.
    You may assume the given input string is always valid. For example, "01:34", "12:09" are all valid. "1:34", "12:9" are all invalid.

    Example 1:

    >>> nextClosestTime(time = "19:34")
    >>> "19:39"
    Explanation: The next closest time choosing from digits 1, 9, 3, 4, is 19:39, which occurs 5 minutes later.
    It is not 19:33, because this occurs 23 hours and 59 minutes later.

    Example 2:

    >>> nextClosestTime(time = "23:59")
    >>> "22:22"
    Explanation: The next closest time choosing from digits 2, 3, 5, 9, is 22:22.
    It may be assumed that the returned time is next day's time since it is smaller than the input time numerically.
    """


Prompt:
from typing import List
def calPoints(operations: List[str]) -> int:
    """
    You are keeping the scores for a baseball game with strange rules. At the beginning of the game, you start with an empty record.
    You are given a list of strings operations, where operations[i] is the ith operation you must apply to the record and is one of the following:

    An integer x.

    Record a new score of x.

    '+'.

    Record a new score that is the sum of the previous two scores.

    'D'.

    Record a new score that is the double of the previous score.

    'C'.

    Invalidate the previous score, removing it from the record.

    Return the sum of all the scores on the record after applying all the operations.
    The test cases are generated such that the answer and all intermediate calculations fit in a 32-bit integer and that all operations are valid.

    Example 1:

    >>> calPoints(ops = ["5","2","C","D","+"])
    >>> 30
    Explanation:
    "5" - Add 5 to the record, record is now [5].
    "2" - Add 2 to the record, record is now [5, 2].
    "C" - Invalidate and remove the previous score, record is now [5].
    "D" - Add 2 * 5 = 10 to the record, record is now [5, 10].
    "+" - Add 5 + 10 = 15 to the record, record is now [5, 10, 15].
    The total sum is 5 + 10 + 15 = 30.

    Example 2:

    >>> calPoints(ops = ["5","-2","4","C","D","9","+","+"])
    >>> 27
    Explanation:
    "5" - Add 5 to the record, record is now [5].
    "-2" - Add -2 to the record, record is now [5, -2].
    "4" - Add 4 to the record, record is now [5, -2, 4].
    "C" - Invalidate and remove the previous score, record is now [5, -2].
    "D" - Add 2 * -2 = -4 to the record, record is now [5, -2, -4].
    "9" - Add 9 to the record, record is now [5, -2, -4, 9].
    "+" - Add -4 + 9 = 5 to the record, record is now [5, -2, -4, 9, 5].
    "+" - Add 9 + 5 = 14 to the record, record is now [5, -2, -4, 9, 5, 14].
    The total sum is 5 + -2 + -4 + 9 + 5 + 14 = 27.

    Example 3:

    >>> calPoints(ops = ["1","C"])
    >>> 0
    Explanation:
    "1" - Add 1 to the record, record is now [1].
    "C" - Invalidate and remove the previous score, record is now [].
    Since the record is empty, the total sum is 0.
    """


Prompt:
from typing import List
def kEmptySlots(bulbs: List[int], k: int) -> int:
    """
    You have n bulbs in a row numbered from 1 to n. Initially, all the bulbs are turned off. We turn on exactly one bulb every day until all bulbs are on after n days.
    You are given an array bulbs of length n where bulbs[i] = x means that on the (i+1)th day, we will turn on the bulb at position x where i is 0-indexed and x is 1-indexed.
    Given an integer k, return the minimum day number such that there exists two turned on bulbs that have exactly k bulbs between them that are all turned off. If there isn't such day, return -1.

    Example 1:

    >>> kEmptySlots(bulbs = [1,3,2], k = 1)
    >>> 2
    Explanation:
    On the first day: bulbs[0] = 1, first bulb is turned on: [1,0,0]
    On the second day: bulbs[1] = 3, third bulb is turned on: [1,0,1]
    On the third day: bulbs[2] = 2, second bulb is turned on: [1,1,1]
    We return 2 because on the second day, there were two on bulbs with one off bulb between them.
    Example 2:

    >>> kEmptySlots(bulbs = [1,2,3], k = 1)
    >>> -1
    """


Prompt:
from typing import List
def findRedundantConnection(edges: List[List[int]]) -> List[int]:
    """
    In this problem, a tree is an undirected graph that is connected and has no cycles.
    You are given a graph that started as a tree with n nodes labeled from 1 to n, with one additional edge added. The added edge has two different vertices chosen from 1 to n, and was not an edge that already existed. The graph is represented as an array edges of length n where edges[i] = [ai, bi] indicates that there is an edge between nodes ai and bi in the graph.
    Return an edge that can be removed so that the resulting graph is a tree of n nodes. If there are multiple answers, return the answer that occurs last in the input.

    Example 1:

    >>> findRedundantConnection(edges = [[1,2],[1,3],[2,3]])
    >>> [2,3]

    Example 2:

    >>> findRedundantConnection(edges = [[1,2],[2,3],[3,4],[1,4],[1,5]])
    >>> [1,4]
    """


Prompt:
from typing import List
def findRedundantDirectedConnection(edges: List[List[int]]) -> List[int]:
    """
    In this problem, a rooted tree is a directed graph such that, there is exactly one node (the root) for which all other nodes are descendants of this node, plus every node has exactly one parent, except for the root node which has no parents.
    The given input is a directed graph that started as a rooted tree with n nodes (with distinct values from 1 to n), with one additional directed edge added. The added edge has two different vertices chosen from 1 to n, and was not an edge that already existed.
    The resulting graph is given as a 2D-array of edges. Each element of edges is a pair [ui, vi] that represents a directed edge connecting nodes ui and vi, where ui is a parent of child vi.
    Return an edge that can be removed so that the resulting graph is a rooted tree of n nodes. If there are multiple answers, return the answer that occurs last in the given 2D-array.

    Example 1:

    >>> findRedundantDirectedConnection(edges = [[1,2],[1,3],[2,3]])
    >>> [2,3]

    Example 2:

    >>> findRedundantDirectedConnection(edges = [[1,2],[2,3],[3,4],[4,1],[1,5]])
    >>> [4,1]
    """


Prompt:
def repeatedStringMatch(a: str, b: str) -> int:
    """
    Given two strings a and b, return the minimum number of times you should repeat string a so that string b is a substring of it. If it is impossible for b to be a substring of a after repeating it, return -1.
    Notice: string "abc" repeated 0 times is "", repeated 1 time is "abc" and repeated 2 times is "abcabc".

    Example 1:

    >>> repeatedStringMatch(a = "abcd", b = "cdabcdab")
    >>> 3
    Explanation: We return 3 because by repeating a three times "abcdabcdabcd", b is a substring of it.

    Example 2:

    >>> repeatedStringMatch(a = "a", b = "aa")
    >>> 2
    """


Prompt:
from typing import Optional
class TreeNode:
    def __init__(val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def longestUnivaluePath(root: Optional[TreeNode]) -> int:
"""
Given the root of a binary tree, return the length of the longest path, where each node in the path has the same value. This path may or may not pass through the root.
The length of the path between two nodes is represented by the number of edges between them.

Example 1:

>>> longestUnivaluePath(root = [5,4,5,1,1,null,5])
>>> 2
Explanation: The shown image shows that the longest path of the same value (i.e. 5).

Example 2:

>>> longestUnivaluePath(root = [1,4,5,4,4,null,5])
>>> 2
Explanation: The shown image shows that the longest path of the same value (i.e. 4).
"""


Prompt:
def knightProbability(n: int, k: int, row: int, column: int) -> float:
    """
    On an n x n chessboard, a knight starts at the cell (row, column) and attempts to make exactly k moves. The rows and columns are 0-indexed, so the top-left cell is (0, 0), and the bottom-right cell is (n - 1, n - 1).
    A chess knight has eight possible moves it can make, as illustrated below. Each move is two cells in a cardinal direction, then one cell in an orthogonal direction.

    Each time the knight is to move, it chooses one of eight possible moves uniformly at random (even if the piece would go off the chessboard) and moves there.
    The knight continues moving until it has made exactly k moves or has moved off the chessboard.
    Return the probability that the knight remains on the board after it has stopped moving.

    Example 1:

    >>> knightProbability(n = 3, k = 2, row = 0, column = 0)
    >>> 0.06250
    Explanation: There are two moves (to (1,2), (2,1)) that will keep the knight on the board.
    From each of those positions, there are also two moves that will keep the knight on the board.
    The total probability the knight stays on the board is 0.0625.

    Example 2:

    >>> knightProbability(n = 1, k = 0, row = 0, column = 0)
    >>> 1.00000
    """


Prompt:
from typing import List
def maxSumOfThreeSubarrays(nums: List[int], k: int) -> List[int]:
    """
    Given an integer array nums and an integer k, find three non-overlapping subarrays of length k with maximum sum and return them.
    Return the result as a list of indices representing the starting position of each interval (0-indexed). If there are multiple answers, return the lexicographically smallest one.

    Example 1:

    >>> maxSumOfThreeSubarrays(nums = [1,2,1,2,6,7,5,1], k = 2)
    >>> [0,3,5]
    Explanation: Subarrays [1, 2], [2, 6], [7, 5] correspond to the starting indices [0, 3, 5].
    We could have also taken [2, 1], but an answer of [1, 3, 5] would be lexicographically smaller.

    Example 2:

    >>> maxSumOfThreeSubarrays(nums = [1,2,1,2,1,2,1,2,1], k = 2)
    >>> [0,2,4]
    """


Prompt:
from typing import List
def minStickers(stickers: List[str], target: str) -> int:
    """
    We are given n different types of stickers. Each sticker has a lowercase English word on it.
    You would like to spell out the given string target by cutting individual letters from your collection of stickers and rearranging them. You can use each sticker more than once if you want, and you have infinite quantities of each sticker.
    Return the minimum number of stickers that you need to spell out target. If the task is impossible, return -1.
    Note: In all test cases, all words were chosen randomly from the 1000 most common US English words, and target was chosen as a concatenation of two random words.

    Example 1:

    >>> minStickers(stickers = ["with","example","science"], target = "thehat")
    >>> 3
    Explanation:
    We can use 2 "with" stickers, and 1 "example" sticker.
    After cutting and rearrange the letters of those stickers, we can form the target "thehat".
    Also, this is the minimum number of stickers necessary to form the target string.

    Example 2:

    >>> minStickers(stickers = ["notice","possible"], target = "basicbasic")
    >>> -1
    Explanation:
    We cannot form the target "basicbasic" from cutting letters from the given stickers.
    """


Prompt:
from typing import List
def topKFrequent(words: List[str], k: int) -> List[str]:
    """
    Given an array of strings words and an integer k, return the k most frequent strings.
    Return the answer sorted by the frequency from highest to lowest. Sort the words with the same frequency by their lexicographical order.

    Example 1:

    >>> topKFrequent(words = ["i","love","leetcode","i","love","coding"], k = 2)
    >>> ["i","love"]
    Explanation: "i" and "love" are the two most frequent words.
    Note that "i" comes before "love" due to a lower alphabetical order.

    Example 2:

    >>> topKFrequent(words = ["the","day","is","sunny","the","the","the","sunny","is","is"], k = 4)
    >>> ["the","is","sunny","day"]
    Explanation: "the", "is", "sunny" and "day" are the four most frequent words, with the number of occurrence being 4, 3, 2 and 1 respectively.
    """


Prompt:
def hasAlternatingBits(n: int) -> bool:
    """
    Given a positive integer, check whether it has alternating bits: namely, if two adjacent bits will always have different values.

    Example 1:

    >>> hasAlternatingBits(n = 5)
    >>> true
    Explanation: The binary representation of 5 is: 101

    Example 2:

    >>> hasAlternatingBits(n = 7)
    >>> false
    Explanation: The binary representation of 7 is: 111.
    Example 3:

    >>> hasAlternatingBits(n = 11)
    >>> false
    Explanation: The binary representation of 11 is: 1011.
    """


Prompt:
from typing import List
def numDistinctIslands(grid: List[List[int]]) -> int:
    """
    You are given an m x n binary matrix grid. An island is a group of 1's (representing land) connected 4-directionally (horizontal or vertical.) You may assume all four edges of the grid are surrounded by water.
    An island is considered to be the same as another if and only if one island can be translated (and not rotated or reflected) to equal the other.
    Return the number of distinct islands.

    Example 1:

    >>> numDistinctIslands(grid = [[1,1,0,0,0],[1,1,0,0,0],[0,0,0,1,1],[0,0,0,1,1]])
    >>> 1

    Example 2:

    >>> numDistinctIslands(grid = [[1,1,0,1,1],[1,0,0,0,0],[0,0,0,0,1],[1,1,0,1,1]])
    >>> 3
    """


Prompt:
from typing import List
def maxAreaOfIsland(grid: List[List[int]]) -> int:
    """
    You are given an m x n binary matrix grid. An island is a group of 1's (representing land) connected 4-directionally (horizontal or vertical.) You may assume all four edges of the grid are surrounded by water.
    The area of an island is the number of cells with a value 1 in the island.
    Return the maximum area of an island in grid. If there is no island, return 0.

    Example 1:

    >>> maxAreaOfIsland(grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]])
    >>> 6
    Explanation: The answer is not 11, because the island must be connected 4-directionally.

    Example 2:

    >>> maxAreaOfIsland(grid = [[0,0,0,0,0,0,0,0]])
    >>> 0
    """


Prompt:
def countBinarySubstrings(s: str) -> int:
    """
    Given a binary string s, return the number of non-empty substrings that have the same number of 0's and 1's, and all the 0's and all the 1's in these substrings are grouped consecutively.
    Substrings that occur multiple times are counted the number of times they occur.

    Example 1:

    >>> countBinarySubstrings(s = "00110011")
    >>> 6
    Explanation: There are 6 substrings that have equal number of consecutive 1's and 0's: "0011", "01", "1100", "10", "0011", and "01".
    Notice that some of these substrings repeat and are counted the number of times they occur.
    Also, "00110011" is not a valid substring because all the 0's (and 1's) are not grouped together.

    Example 2:

    >>> countBinarySubstrings(s = "10101")
    >>> 4
    Explanation: There are 4 substrings: "10", "01", "10", "01" that have equal number of consecutive 1's and 0's.
    """


Prompt:
from typing import List
def findShortestSubArray(nums: List[int]) -> int:
    """
    Given a non-empty array of non-negative integers nums, the degree of this array is defined as the maximum frequency of any one of its elements.
    Your task is to find the smallest possible length of a (contiguous) subarray of nums, that has the same degree as nums.

    Example 1:

    >>> findShortestSubArray(nums = [1,2,2,3,1])
    >>> 2
    Explanation:
    The input array has a degree of 2 because both elements 1 and 2 appear twice.
    Of the subarrays that have the same degree:
    [1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2]
    The shortest length is 2. So return 2.

    Example 2:

    >>> findShortestSubArray(nums = [1,2,2,3,1,4,2])
    >>> 6
    Explanation:
    The degree is 3 because the element 2 is repeated 3 times.
    So [2,2,3,1,4,2] is the shortest subarray, therefore returning 6.
    """


Prompt:
from typing import List
def canPartitionKSubsets(nums: List[int], k: int) -> bool:
    """
    Given an integer array nums and an integer k, return true if it is possible to divide this array into k non-empty subsets whose sums are all equal.

    Example 1:

    >>> canPartitionKSubsets(nums = [4,3,2,3,5,2,1], k = 4)
    >>> true
    Explanation: It is possible to divide it into 4 subsets (5), (1, 4), (2,3), (2,3) with equal sums.

    Example 2:

    >>> canPartitionKSubsets(nums = [1,2,3,4], k = 3)
    >>> false
    """