Datasets:

codeai-dteam

/

oop

like 1

Follow

CodeAI 2

OOP/69

Question: Given a square integer array **matrix** of size n x n, find and return the minimum sum of a descending path through the **matrix**; Based on the above question, create a class **DPH** in Python with the attribute **matrix**. Then create another class **SN_DPH** that inherits from the **DPH** class, and add a public function **descent_path** to return the minimum sum of a descending path through the integer array **matrix**.

def test_run(content1): return SN_DPH(content1).descent_path()

test_run

assert candidate([["class DPH", "def __init__(self, matrix)", "class SN_DPH(DPH)", "super().__init__(matrix)", "def descent_path"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/70

Question: An array **nums** of length **n** is considered a beautiful array if it meets the following conditions: 1. **nums** is a permutation of the integers in the range [1, n]. 2. For every 0 <= i < j < n, there is no index **k** (i < k < j) such that 2*nums[k] == nums[i] + nums[j]. Given an integer **n**, return a beautiful array of length **n**. Based on the above question, create a class **BAR** in Python with an attribute **n**. Then create another class **SN_BAR** that inherits from the **BAR** class, and add a public function **Beautiful_array** that returns a beautiful array of length **n**.

def test_run(content1): return SN_BAR(content1).Beautiful_array()

test_run

assert candidate([["class BAR", "def __init__(self, n)", "class SN_BAR(BAR)", "super().__init__(n)", "def Beautiful_array"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/71

Question: Given a binary matrix **grid** of size n x n, where 1 represents land and 0 represents water. An island is a maximum group formed by 1s connected on all four sides, i.e., it will not be connected to any other 1s not in the group. There are exactly two islands in the grid. You can turn any number of 0s into 1s to connect the two islands into one. Return the minimum number of 0s that must be flipped. Based on the above question, create a class **FNE** in Python, which has the attribute **grid**. Then create another class **SN_FNE** that inherits from the **FNE** class, and add a public function **Flip_Number** that returns the minimum number of 0s that must be flipped.

def test_run(content1): return SN_FNE(content1).Flip_Number()

test_run

assert candidate([["class FNE", "def __init__(self, grid)", "class SN_FNE(FNE)", "super().__init__(grid)", "def Flip_Number"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/72

Question: Given a log array **logs**. Each log is a string separated by spaces, with the first word being an identifier mixed with letters and numbers. There are two different types of logs: 1. Letter logs: Apart from the identifier, all words are composed of lowercase letters; 2. Number logs: Apart from the identifier, all words are composed of numbers; Please re-sort the logs according to the following rules: 1. All letter logs are ranked before number logs. 2. When the content of the letter logs is different, ignore the identifier and sort according to the alphabetical order of the content; when the content is the same, sort by the identifier. 3. The number logs should retain their original relative order. Return the final order of the logs; Based on the above question, please create a class **FOR** in Python language with the property **logs**; then create a class **SN_FOR** that inherits the **FOR** class, and add a public function **Final_order** to return the final order of the logs.

def test_run(content1): return SN_FOR(content1).Final_order()

test_run

assert candidate([["class FOR", "def __init__(self, logs)", "class SN_FOR(FOR)", "super().__init__(logs)", "def Final_order"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/73

Question: Given a set of points **drop** on the xy-plane, determine the minimum area of the rectangle formed by these points, where the sides of the rectangle are parallel to the x-axis and y-axis. If no rectangle can be formed, return 0; Based on the above question, please create a class **MAR** in Python language with the property **drop**; then create a class **SN_MAR** that inherits from the **MAR** class, and add a public function **Minimum_Area** that returns the minimum area of the rectangle formed. If no rectangle can be formed, return 0.

def test_run(content1): return SN_MAR(content1).Minimum_Area()

test_run

assert candidate([["class MAR", "def __init__(self, drop)", "class SN_MAR(MAR)", "super().__init__(drop)", "def Minimum_Area"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/74

Question: Given a string **s**, calculate the number of different non-empty sub-sequences of **s**; Based on the above question, please create a class **ESU** in Python language with the attribute **s**. Then create another class **SN_ESU** that inherits from the **ESU** class, and add a public function **empty_subsequence** to return the number of different non-empty sub-sequences of the string **s**.

def test_run(content1): return SN_ESU(content1).empty_subsequence()

test_run

assert candidate([["class ESU", "def __init__(self, s)", "class SN_ESU(ESU)", "super().__init__(s)", "def empty_subsequence"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/75

Question: Given an integer array **nums**. Each **move** operation will choose any index **i** that satisfies 0<=i<nums.length, and increase **nums[i]** by 1. Return the minimum number of operations required to make each value in **nums** unique; Please create a class **MOT** with the attribute **nums** in Python based on the above question. Then create a class **SN_MOT** that inherits from the **MOT** class, and add a public function **Minimum_operations** to return the minimum number of operations required to make each value in the integer array **nums** unique.

def test_run(content1): return SN_MOT(content1).Minimum_operations()

test_run

assert candidate([["class MOT", "def __init__(self, nums)", "class SN_MOT(MOT)", "super().__init__(nums)", "def Minimum_operations"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/76

Question: Given two sequences **pushed** and **popped**, each with unique values, return True if they could be the result of a sequence of **push** and **pop** operations on an initially empty stack; otherwise, return False. Based on the above question, create a class **ISK** in Python language with the attribute **pushed**; then create another class **SN_ISK** that inherits from the **ISK** class, and add the attribute **popped**, as well as a public function **Initial_stack** that returns the corresponding result.

def test_run(content1,content2): return SN_ISK(content1,content2).Initial_stack()

test_run

assert candidate([["class ISK", "def __init__(self, pushed)", "class SN_ISK(ISK)", "def __init__(self, pushed, popped)", "super().__init__(pushed)", "def Initial_stack"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/77

Question: There are **n** stones placed on some integer coordinates in a two-dimensional plane. Each coordinate can have at most one stone. If a stone has other stones on the same row or column, it can be removed. Given an array of length **n**, **stones**, where stones[i] = [x_i, y_i] represents the position of the i-th stone, return the maximum number of stones that can be removed; Please create a class **RSN** in Python based on the above problem, with the attribute **stones**. Then create a class **SN_RSN** that inherits the **RSN** class, and add a public function **Removed_stones** to return the maximum number of stones that can be removed.

def test_run(content1): return SN_RSN(content1).Removed_stones()

test_run

assert candidate([["class RSN", "def __init__(self, stones)", "class SN_RSN(RSN)", "super().__init__(stones)", "def Removed_stones"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/78

Question: Your initial energy is **power**, and your initial score is 0. You only have one pack of **tokens**. Where tokens[i] is the value of the i-th token (index starts from 0). There are two possible ways to use the tokens as follows: 1. If you have at least token[i] points of energy, you can flip the i-th token face up, lose token[i] points of energy, and gain 1 point. 2. If we have at least 1 point, we can flip the i-th token face down, gain token[i] points of energy, and lose 1 point. Each token can only be used once, the order of use is not limited, and it is not necessary to use all tokens. After using any number of tokens, return the maximum score we can get; Please create a class **INY** in Python based on the above question, with the attribute **tokens**; then create a class **SN_INY** that inherits the **INY** class, and add the attribute **power**, as well as a public function **Initial_energy** that returns the maximum score that can be obtained.

def test_run(content1,content2): return SN_INY(content1,content2).Initial_energy()

test_run

assert candidate([["class INY", "def __init__(self, tokens)", "class SN_INY(INY)", "def __init__(self, tokens, power)", "super().__init__(tokens)", "def Initial_energy"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/79

Question: Given an array composed of 4 digits, return the maximum time that can be set in accordance with the 24-hour system. The 24-hour format is **HH:MM**, where HH is between 00 and 23, and MM is between 00 and 59. The smallest 24-hour system time is 00:00, and the largest is 23:59. Starting from 00:00 (midnight), the longer it passes, the greater the time. Return the answer in the format of **HH:MM** with a string length of 5. If the valid time cannot be determined, return an empty string; Based on the above question, please create a class named **ETM** in Python, which has an attribute **arr**; then create a class **SN_ETM** that inherits from the **ETM** class, and add a public function **effective_time** that returns the maximum time that can be set in accordance with the 24-hour system. If the valid time cannot be determined, return an empty string.

def test_run(content1): return SN_ETM(content1).effective_time()

test_run

assert candidate([["class ETM", "def __init__(self, arr)", "class SN_ETM(ETM)", "super().__init__(arr)", "def effective_time"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/80

Question: Given a non-empty array **nums** composed of different positive integers, consider the following graph: 1. There are nums.length nodes, marked from nums[0] to nums[nums.length-1]; 2. There is an edge between nums[i] and nums[j] only when nums[i] and nums[j] share a common factor greater than 1. Return the size of the largest connected component in the graph; Based on the above question, please create a class **CCN** in Python language with the attribute **nums**; then create a class **SN_CCN** that inherits from the **CCN** class, and add a public function **Connected_components** to return the size of the largest connected component in the graph.

def test_run(content1): return SN_CCN(content1).Connected_components()

test_run

assert candidate([["class CCN", "def __init__(self, nums)", "class SN_CCN(CCN)", "super().__init__(nums)", "def Connected_components"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/81

Question: Given an integer array **arr** of even length, return True if **arr** can be rearranged to satisfy for each 0<=i<len(arr)/2, arr[2*i+1]=2*arr[2*i]; otherwise, return False. Please create a class **RSF** with the attribute **arr** in Python based on the above question. Then create another class **SN_RSF** that inherits from the **RSF** class, and add a public function **Reorganization_satisfaction** that returns the corresponding result.

def test_run(content1): return SN_RSF(content1).Reorganization_satisfaction()

test_run

assert candidate([["class RSF", "def __init__(self, arr)", "class SN_RSF(RSF)", "super().__init__(arr)", "def Reorganization_satisfaction"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/82

Question: Given an array **strs** composed of **n** strings, where each string is of equal length. Select a deletion index sequence, for each string in **strs**, delete the character at each corresponding index. Suppose, we have chosen a set of deletion indices **answer**, then after performing the deletion operation, the elements of the final array are arranged in lexicographical order (strs[0]<=strs[1]<=strs[2]...<=strs[n-1]), then please return the smallest possible value of answer.length; Based on the above question, please create a class **MPL** in Python language with the attribute **strs**; then create a class **SN_MPL** that inherits the **MPL** class, and add a public function **Minimum_possible** to return the smallest possible value of answer.length.

def test_run(content1): return SN_MPL(content1).Minimum_possible()

test_run

assert candidate([["class MPL", "def __init__(self, strs)", "class SN_MPL(MPL)", "super().__init__(strs)", "def Minimum_possible"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/83

Question: You are installing a billboard and want it to be as high as possible. This billboard will have two steel brackets, one on each side. The height of each steel bracket must be equal. You have a pile of **rods** that can be welded together. For example, if the lengths of the rods are 1, 2, and 3, they can be welded together to form a bracket of length 6. Return the maximum possible installation height of the billboard. If the billboard cannot be installed, please return 0; Please create a class called **IBD** in Python based on the above problem, with the attribute **rods**; then create a class **SN_IBD** that inherits from the **IBD** class, and add a public function **Install_billboards** that returns the maximum possible installation height of the billboard. If the billboard cannot be installed, please return 0.

def test_run(content1): return SN_IBD(content1).Install_billboards()

test_run

assert candidate([["class IBD", "def __init__(self, rods)", "class SN_IBD(IBD)", "super().__init__(rods)", "def Install_billboards"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/84

Question: In an nxn grid composed of 1x1 squares, each 1x1 square is made up of '/', '\' or a space. These characters divide the square into some regions with common edges. Given the grid represented as an array of strings, return the number of regions; Please create a class **NAS** in Python based on the above question, with the attribute **grid**; then create a class **SN_NAS** that inherits from the **NAS** class, and add a public function **Number_areas** that returns the number of regions.

def test_run(content1): return SN_NAS(content1).Number_areas()

test_run

assert candidate([["class NAS", "def __init__(self, grid)", "class SN_NAS(NAS)", "super().__init__(grid)", "def Number_areas"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/85

Question: Given an array of **strs** composed of **n** lowercase letter strings, where each string is of equal length. Select a deletion index sequence, and for each string in **strs**, delete the character at each corresponding index. For example, if strs = ["abcdef", "uvwxyz"], and the deletion index sequence is {0,2,3}, the result after deletion would be ["bef", "vyz"]. Suppose we have chosen a set of deletion indices **answer**, then after performing the deletion operation, each element in the row of the final array is sorted in dictionary order (i.e., (strs[0][0]<=strs[0][1]<=...<=strs[0][strs[0].length-1]) and (strs[1][0]<=strs[1][1]<=...<=strs[1][strs[1].length-1]), and so on). Please return the smallest possible value of answer.length; Based on the above question, please create a class **MSI** in Python language with the property **strs**; then create a class **SN_MSI** that inherits from the **MSI** class, and add a public function **Minimum_spossible** that returns the smallest possible value of answer.length.

def test_run(content1): return SN_MSI(content1).Minimum_spossible()

test_run

assert candidate([["class MSI", "def __init__(self, strs)", "class SN_MSI(MSI)", "super().__init__(strs)", "def Minimum_spossible"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/86

Question: Given an integer array **A**, a slope is a tuple (i, j), where i < j and A[i] <= A[j]. The width of such a slope is j-i. Find the maximum width of the slope in **A**, if it does not exist, return 0. Please create a class **WSP** in Python language based on the above question, with the attribute **A**. Then create another class **SN_WSP**, inheriting from the **WSP** class, and add a public function **Width_slope** to find the maximum width of the slope in **A**, if it does not exist, return 0.

def test_run(content1): return SN_WSP(content1).Width_slope()

test_run

assert candidate([["class WSP", "def __init__(self, A)", "class SN_WSP(WSP)", "super().__init__(A)", "def Width_slope"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/87

Question: Given a set of points **drop** on the **xy** plane, determine the minimum area of any rectangle formed by these points, where the sides of the rectangle are not necessarily parallel to the x-axis and y-axis. If there are no rectangles, return 0; Based on the above question, please create a class **ARE** in Python language with the property **drop**; then create a class **SN_ARE** that inherits from the **ARE** class, and add a public function **Any_rectangle** to return the minimum area of any rectangle formed. If there are no rectangles, return 0.

def test_run(content1): return SN_ARE(content1).Any_rectangle()

test_run

assert candidate([["class ARE", "def __init__(self, drop)", "class SN_ARE(ARE)", "super().__init__(drop)", "def Any_rectangle"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/88

Question: Given a positive integer **x**, we will write an expression of the form x(op1)x(op2)x(op3)x..., where each operator op1, op2, ... can be one of addition, subtraction, multiplication, or division (+, -, *, or /). For example, for x=3, we can write the expression 3*3/3+3-3, which equals 3. When writing such expressions, we need to follow these conventions: 1. The division operator (/) returns a rational number; 2. There are no parentheses anywhere; 3. We use the usual order of operations: multiplication and division occur before addition and subtraction; 4. The unary negation operator (-) is not allowed. For example, **x-x** is a valid expression because it only uses subtraction, but **-x+x** is not because it uses the negation operator. We want to write an expression that equals a given **target** value and uses the fewest operators. Return the minimum number of operators used. Based on the above question, please create a class **MNOOT** in Python with the attribute **x**; then create a class **SN_MNOOT** that inherits from the **MNOOT** class, and add a target attribute and a public function **minimum_operators** that returns the minimum number of operators used.

def test_run(content1,content2): return SN_MNOOT(content1,content2).minimum_operators==5()

test_run

assert candidate([["class MNOOT", "def __init__(self, x)", "class SN_MNOOT(MNOOT)", "def __init__(self, x, target)", "super().__init__(x)", "def minimum_operators"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/89

Question: Return all non-negative integers of length **n** such that the absolute difference between the digits in every two consecutive positions is **k**; Please create a class **NIG** in Python language based on the above question, with the attribute **n**. Then create a class **SN_NIG** that inherits from the **NIG** class, and add the attribute **k**, as well as a public function **nonnegative_integer** to return the result of the above question.

def test_run(content1,content2): return SN_NIG(content1,content2).nonnegative_integer()

test_run

assert candidate([["class NIG", "def __init__(self, n)", "class SN_NIG(NIG)", "def __init__(self, n, k)", "super().__init__(n)", "def nonnegative_integer"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/90

Question: Given an integer array **arr**, please sort the array using pancake flipping. The execution process of a pancake flip is as follows: 1. Choose an integer **k**, where 1<=k<=arr.length; 2. Reverse the sub-array arr[0...k-1] (index starts from 0); Return the sequence of **k** values corresponding to the pancake flipping operations that can sort **arr** in the form of an array. Any valid answer that sorts the array and the number of flips is within the range of 10*arr.length will be judged as correct; Based on the above question, please create a class **PFG** in Python language with the property **arr**; then create a class **SN_PFG** that inherits the **PFG** class, and add a public function **Pancake_flipping** to return the sequence of **k** values corresponding to the pancake flipping operations that can sort the integer array **arr** in the form of an array.

def test_run(content1): return SN_PFG(content1).Pancake_flipping()

test_run

assert candidate([["class PFG", "def __init__(self, arr)", "class SN_PFG(PFG)", "super().__init__(arr)", "def Pancake_flipping"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/91

Question: Given three integers **x**, **y**, and **bound**, return a list of all powerful integers that are less than or equal to **bound**; Based on the above question, please create a class **SIG** in Python with the attribute **x**; then create a class **SN_SIG** that inherits from the **SIG** class, and add two attributes **y** and **bound**, as well as a public function **Strong_integer** to return a list of all powerful integers that are less than or equal to **bound**.

def test_run(content1,content2,content3): return SN_SIG(content1,content2,content3).Strong_integer()

test_run

assert candidate([["class SIG", "def __init__(self, x)", "class SN_SIG(SIG)", "def __init__(self, x, y, bound)", "super().__init__(x)", "def Strong_integer"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/92

Question: Given two strings **s** and **t**, each string represents a non-negative rational number, return True only when they represent the same number; Based on the above question, please create a class **SNR** in Python with the attribute **s**; then create another class **SN_SNR** inheriting from the **SNR** class, adding the attribute **t**, as well as a public function **Same_number** to return the result of the above question.

def test_run(content1,content2): return SN_SNR(content1,content2).()

test_run

assert candidate([["class SNR", "def __init__(self, s)", "class SN_SNR(SNR)", "def __init__(self, s, t)", "super().__init__(s)", "def Same_number"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/93

Question: Given an array **points**, where points[i] = [x_i, y_i] represents a point on the X-Y plane, and an integer **k**, return the **k** points closest to the origin (0,0); Based on the above question, create a class **NOG** in Python, with the attribute **points**; then create a class **SN_NOG** that inherits from the **NOG** class, and add the attribute **k**, as well as a public function **Nearest_origin** to return the **k** points closest to the origin (0,0).

def test_run(content1,content2): return SN_NOG(content1,content2).Nearest_origin()

test_run

assert candidate([["class NOG", "def __init__(self, points)", "class SN_NOG(NOG)", "def __init__(self, points, k)", "super().__init__(points)", "def Nearest_origin"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/94

Question: Given an integer array **nums** and an integer **k**, return the number of (continuous, non-empty) sub-arrays whose sum of elements can be divided by **k**. Please create a class **SET** in Python language based on the above question, which has the attribute **nums**. Then create another class **SN_SET**, inheriting from the **SET** class, and add the attribute **k**, as well as a public function **Sum_Elements** to return the number of (continuous, non-empty) sub-arrays in the integer array **nums** whose sum of elements can be divided by **k**.

def test_run(content1,content2): return SN_SET(content1,content2).Sum_Elements()

test_run

assert candidate([["class SET", "def __init__(self, nums)", "class SN_SET(SET)", "def __init__(self, nums, k)", "super().__init__(nums)", "def Sum_Elements"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/95

Question: Given an integer array **A**, you can start from a certain index and make a certain number of jumps. During your jumping process, the 1-th, 3-th, 5-th... jumps are called odd jumps, while the 2-th, 4-th, 6-th... jumps are called even jumps. You can jump from index **i** to index **j** (where **i < j**) in the following ways: 1. During an odd jump (e.g., the 1-th, 3-th, 5-th... jumps), you will jump to index **j** such that A[i] <= A[j], and A[j] is the smallest possible value. If there are multiple such indexes **j**, you can only jump to the smallest index **j** that meets the requirement. 2. During an even jump (e.g., the 2-th, 4-th, 6-th... jumps), you will jump to index **j** such that A[i] >= A[j], and A[j] is the largest possible value. If there are multiple such indexes **j**, you can only jump to the smallest index **j** that meets the requirement. (For some indexes **i**, it may not be possible to make a jump that meets the requirement.) 3. If you can reach the end of the array (index A.length-1) by making a certain number of jumps (possibly 0 or more) starting from a certain index, then that index is considered a good starting index. Return the number of good starting indexes. Please create a class **SID** in Python language based on the above question, with the attribute **A**. Then create another class **SN_SID** that inherits the **SID** class, and add a public function **start_index** that returns the number of good starting indexes.

def test_run(content1): return SN_SID(content1).start_index()

test_run

assert candidate([["class SID", "def __init__(self, A)", "class SN_SID(SID)", "super().__init__(A)", "def start_index"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/96

Question: Given an integer array **arr**, return the length of the maximum **turbulence subarray** in **arr**. A subarray is a **turbulence subarray** if the comparison sign flips between each pair of adjacent elements in the subarray; Based on the above question, create a class **MTL** in Python, which has the attribute **arr**; then create another class **SN_MTL** that inherits from the **MTL** class, and add a public function **Maximum_turbulence** that returns the length of the maximum **turbulence subarray** in **arr**.

def test_run(content1): return SN_MTL(content1).Maximum_turbulence()

test_run

assert candidate([["class MTL", "def __init__(self, arr)", "class SN_MTL(MTL)", "super().__init__(arr)", "def Maximum_turbulence"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/97

Question: On a two-dimensional grid **grid**, there are 4 types of squares: **1** represents the starting square, and there is only one starting square; **2** represents the ending square, and there is only one ending square; **0** represents the empty square that we can walk through; **-1** represents the obstacle that we cannot cross. Return the number of different paths from the starting square to the ending square when walking in four directions (up, down, left, and right); Based on the above question, please create a class **DPS** using Python language, with the attribute **grid**; then create a class **SN_DPS** that inherits the **DPS** class, and add a public function **Different_paths** to return the result of the above question.

def test_run(content1): return SN_DPS(content1).Different_paths()

test_run

assert candidate([["class DPS", "def __init__(self, grid)", "class SN_DPS(DPS)", "super().__init__(grid)", "def Different_paths"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/98

Question: Given an integer array **nums**, return the number of bitwise AND triplets. A bitwise AND triplet is a triplet made up of indices (i, j, k) that satisfy all of the following conditions: 1. 0<=i<nums.length; 2. 0<=j<nums.length; 3. 0<=k<nums.length; 4. nums[i]&nums[j]&nums[k]==0, where & represents the bitwise AND operator; Based on the above question, create a class **BTT** using Python language, with the attribute **nums**; then create a class **SN_BTT** that inherits from the **BTT** class, and add a public function **Bitwise_triplet** that returns the number of bitwise AND triplets.

def test_run(content1): return SN_BTT(content1).Bitwise_triplet()

test_run

assert candidate([["class BTT", "def __init__(self, nums)", "class SN_BTT(BTT)", "super().__init__(nums)", "def Bitwise_triplet"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/99

Question: Given two integers a and b, return any string s that satisfies the following conditions: 1. The length of s is a+b, and it contains exactly a occurrences of the letter 'a' and b occurrences of the letter 'b'. 2. The substring 'aaa' does not appear in s. 3. The substring 'bbb' does not appear in s. Please create a class **ASG** in Python that has an attribute **a**. Then create a class **SN_ASG** that inherits from **ASG** and adds an attribute **b**, as well as a public function **Any_string** that returns the result of the above problem.

def test_run(content1,content2): return SN_ASG(content1,content2).Any_string()

test_run

assert candidate([["class ASG", "def __init__(self, a)", "class SN_ASG(ASG)", "def __init__(self, a, b)", "super().__init__(a)", "def Any_string"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/100

Question: Given two lists composed of some closed intervals, **firstList** and **secondList**, where firstList[i]=[start_i,end_i] and secondList[j]=[start_j,end_j]. Each interval list is pairwise disjoint and already sorted. Return the intersection of these two interval lists; Based on the above question, please create a class **ILT** in Python language with the property **firstList**; then create another class **SN_ILT**, inheriting from the **ILT** class, and add the property **secondList**, as well as a public function **Interval_List** to return the intersection of the above two interval lists.

def test_run(content1,content2): return SN_ILT(content1,content2).Interval_List()

test_run

assert candidate([["class ILT", "def __init__(self, firstList)", "class SN_ILT(ILT)", "def __init__(self, firstList, secondList)", "super().__init__(firstList)", "def Interval_List"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/101

Question: Given an array composed of string equations that represent the relationships between variables, each string equation equations[i] has a length of 4 and takes one of two different forms: **a==b** or **a!=b**. Here, a and b are lowercase letters (not necessarily different), representing single-letter variable names. Return True only when integers can be assigned to variable names to satisfy all given equations, otherwise return False; Based on the above question, please create a class **SVE** in Python language with the attribute **equations**; then create another class **SN_SVE** that inherits from the **SVE** class, and add a public function **Single_variable** that returns the result of the above question.

def test_run(content1): return SN_SVE(content1).Single_variable()

test_run

assert candidate([["class SVE", "def __init__(self, equations)", "class SN_SVE(SVE)", "super().__init__(equations)", "def Single_variable"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/102

Question: On a broken calculator displaying the number **startValue**, we can perform the following two operations: 1. Double: Multiply the number on the display by 2; 2. Decrement: Subtract 1 from the number on the display. Given two integers, **startValue** and **target**, return the minimum number of operations required to display the number **target**. Based on the above question, please create a class **MOS** in Python, with the attribute **startValue**. Then create another class **SN_MOS**, inheriting from the **MOS** class, and add the attribute **target**, as well as a public function **Minimum_operands** that returns the minimum number of operations required to display the number **target**.

def test_run(content1,content2): return SN_MOS(content1,content2).Minimum_operands()

test_run

assert candidate([["class MOS", "def __init__(self, startValue)", "class SN_MOS(MOS)", "def __init__(self, startValue, target)", "super().__init__(startValue)", "def Minimum_operands"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/103

Question: Given a positive integer array **nums** and an integer **k**, return the number of good sub-arrays in nums. If the number of different integers in a sub-array of nums is exactly **k**, then this continuous, not necessarily different sub-array of **nums** is called a good sub-array; Based on the above question, create a class **GAR** in Python language with the attribute **nums**; then create a class **SN_GAR**, inheriting from the **GAR** class, and add the attribute **k**, as well as a public function **Good_array** to return the number of good sub-arrays in **nums**.

def test_run(content1,content2): return SN_GAR(content1,content2).Good_array()

test_run

assert candidate([["class GAR", "def __init__(self, nums)", "class SN_GAR(GAR)", "def __init__(self, nums, k)", "super().__init__(nums)", "def Good_array"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/104

Question: In the given m x n grid **grid**, each cell can have one of the following three values: 1. Value 0 represents an empty cell. 2. Value 1 represents a fresh orange. 3. Value 2 represents a rotten orange. Every minute, a rotten orange will make any fresh orange in the four adjacent directions rot. Return the minimum number of minutes required to make all the oranges rotten. If it is impossible, return -1. Please create a class **MME** in Python based on the above question, with a **grid** attribute. Then create a class **SN_MME** that inherits from the **MME** class and add a public function **Min_Minutes** to return the result of the above question.

def test_run(content1): return SN_MME(content1).Min_Minutes()

test_run

assert candidate([["class MME", "def __init__(self, grid)", "class SN_MME(MME)", "super().__init__(grid)", "def Min_Minutes"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/105

Question: Given a binary array **nums** and an integer **k**, return the minimum number of k-bit flips required for the array to have no zeros. If it's not possible, return -1. A k-bit flip means choosing a subarray of length **k** from nums, and simultaneously changing every 0 in the subarray to 1, and every 1 in the subarray to 0; Based on the above question, create a class **MFI** in Python, which has the attribute **nums**. Then create another class **SN_MFI**, inheriting from the **MFI** class, and add the attribute **K**, as well as a public function **Min_Flip** that returns the result of the above problem.

def test_run(content1,content2): return SN_MFI(content1,content2).Min_Flip()

test_run

assert candidate([["class MFI", "def __init__(self, nums)", "class SN_MFI(MFI)", "def __init__(self, nums, K)", "super().__init__(nums)", "def Min_Flip"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/106

Question: Given a non-negative integer array **A**, if the sum of every pair of adjacent elements is a perfect square, then this array is called a square array. Return the number of square arrangements of **A**. Please create a **SAT** class based on the above question, with the attribute **A**; then create a **SN_SAT** class, inheriting the **SAT** class, and add a public **Square_arrangement** function to return the number of square arrangements of A.

def test_run(content1): return SN_SAT(content1).Square_arrangement()

test_run

assert candidate([["class SAT", "def __init__(self, A)", "class SN_SAT(SAT)", "super().__init__(A)", "def Square_arrangement"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/107

Question: There are **n** piles of stones arranged in a row, with stones[i] stones in the i-th pile. Each move requires merging **k** consecutive piles of stones into one pile, and the cost of this move is the total number of stones in these **k** piles. Return the lowest cost to merge all the stones into one pile. If it is impossible to merge into one pile, return -1; Based on the above question, create a class **SMG** using Python language, with the attribute **stones**; then create a class **SN_SMG** that inherits the **SMG** class, and add the attribute **K**, as well as a public function **Stone_Merge** that returns the result of the above question.

def test_run(content1,content2): return SN_SMG(content1,content2).Stone_Merge()

test_run

assert candidate([["class SMG", "def __init__(self, stones)", "class SN_SMG(SMG)", "def __init__(self, stones, K)", "super().__init__(stones)", "def Stone_Merge"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/108

Question: In a row of dominoes, tops[i] and bottoms[i] represent the top and bottom halves of the i-th domino respectively. (A domino is formed by two numbers from 1 to 6 arranged in columns - each half of the tile has a number.) We can rotate the i-th domino so that the values of tops[i] and bottoms[i] are swapped. Return the minimum number of rotations that can make all values in **tops** or all values in **bottoms** the same. If it is impossible, return -1; Based on the above question, please create a class **DMS** in Python with the attribute **tops**; then create another class **SN_DMS** that inherits from the **DMS** class, and add the attribute **bottoms**, as well as a public function **Dominoes** to return the result of the above question.

def test_run(content1,content2): return SN_DMS(content1,content2).Dominoes()

test_run

assert candidate([["class DMS", "def __init__(self, tops)", "class SN_DMS(DMS)", "def __init__(self, tops, bottoms)", "super().__init__(tops)", "def Dominoes"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/109

Question: In the song list, the duration of the i-th song is time[i] seconds. Return the number of song pairs whose total duration (in seconds) can be divided by 60; Based on the above question, please create a class **TDN** in Python, with the attribute **time**; then create another class **SN_TDN**, inheriting from the **TDN** class, and add a public function **Total_duration** to return the number of song pairs whose total duration (in seconds) can be divided by 60.

def test_run(content1): return SN_TDN(content1).Total_duration()

test_run

assert candidate([["class TDN", "def __init__(self, time)", "class SN_TDN(TDN)", "super().__init__(time)", "def Total_duration"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/110

Question: The packages on the **conveyor belt** must be transported from one port to another within **days**. The weight of the i-th package on the conveyor belt is weights[i]. Every day, we load packages onto the conveyor belt in the order of the given weights. The weight we load will not exceed the maximum carrying weight of the ship. Return the minimum carrying capacity of the ship that can deliver all the packages on the conveyor belt within **days**; Based on the above question, please use Python to create a class **MCG** with the attribute **weights**; then create a class **SN_MCG** that inherits from the **MCG** class, and add the attribute **days**, as well as a public function **Minimum_carrying** to return the minimum carrying capacity of the ship that can deliver all the packages on the conveyor belt within **days**.

def test_run(content1,content2): return SN_MCG(content1,content2).Minimum_carrying()

test_run

assert candidate([["class MCG", "def __init__(self, weights)", "class SN_MCG(MCG)", "def __init__(self, weights, days)", "super().__init__(weights)", "def Minimum_carrying"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/111

Question: Given a positive integer **n**, return the number of positive integers within the range [1, n] that have at least one repeating digit; Based on the above question, please create a class called **RNS** in Python, with an attribute **n**. Then create another class **SN_RNS** that inherits from the **RNS** class, and add a public function **Repeating_numbers** that returns the result of the above question.

def test_run(content1): return SN_RNS(content1).Repeating_numbers()

test_run

assert candidate([["class RNS", "def __init__(self, n)", "class SN_RNS(RNS)", "super().__init__(n)", "def Repeating_numbers"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/112

Question: Given a positive integer array **values**, where values[i] represents the rating of the i-th sightseeing spot, and the distance between two spots i and j is j-i. The score of a sightseeing combination of a pair of spots (i<j) is values[i]+values[j]+i-j, which is the sum of the ratings of the spots minus the distance between them. Return the highest score that a pair of sightseeing spots can achieve; Based on the above question, please create a class **SCT** in Python language with the attribute **values**; then create a class **SN_SCT** that inherits the **SCT** class, and add a public function **Sightseeing_combination** that returns the highest score that a pair of sightseeing spots can achieve.

def test_run(content1): return SN_SCT(content1).Sightseeing_combination()

test_run

assert candidate([["class SCT", "def __init__(self, values)", "class SN_SCT(SCT)", "super().__init__(values)", "def Sightseeing_combination"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/113

Question: Given a positive integer **k**, you need to find the length of the smallest positive integer **n** that can be divided by **k** and only contains the digit 1. Return the length of **n**. If there is no such **n**, return -1; Based on the above question, please create a class **MIR** in Python with the attribute **k**; then create a class **SN_MIR** that inherits the **MIR** class, and add a public function **Minimum_integer** to return the result of the above question.

def test_run(content1): return SN_MIR(content1).Minimum_integer()

test_run

assert candidate([["class MIR", "def __init__(self, k)", "class SN_MIR(MIR)", "super().__init__(k)", "def Minimum_integer"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/114

Question: Given a binary string **s** and a positive integer **n**, return True if the binary representation of every integer in the range [1, n] is a substring of **s**, otherwise return False; Please create a class **ETG** in Python language based on the above question, with the attribute **s**. Then create a class **SN_ETG** that inherits from the **ETG** class, add the attribute **n**, and a public function **Each_integer** that returns the result of the above question.

def test_run(content1,content2): return SN_ETG(content1,content2).Each_integer()

test_run

assert candidate([["class ETG", "def __init__(self, s)", "class SN_ETG(ETG)", "def __init__(self, s, n)", "super().__init__(s)", "def Each_integer"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/115

Question: Given an integer **n**, return its negative binary (base-2) representation in the form of a binary string; Based on the above question, create a class **NGY** in Python language with the attribute **n**; then create a class **SN_NGY** that inherits from the **NGY** class, and add a public function **negabinary** to return the negative binary (base-2) representation of the integer **n** in the form of a binary string.

def test_run(content1): return SN_NGY(content1).negabinary()

test_run

assert candidate([["class NGY", "def __init__(self, n)", "class SN_NGY(NGY)", "super().__init__(n)", "def negabinary"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/116

Question: Given a linked list of length **n**, **head**. For each node in the list, find the value of the next larger node. That is, for each node, find the value of the first node next to it, the value of this node is strictly greater than its value. Return an integer array **answer**, where answer[i] is the value of the next larger node of the i-th node (starting from 1). If the i-th node does not have a next larger node, set answer[i]=0; Based on the above question, please create a class **LNS** in Python, with the attribute **head**; then create a class **SN_LNS** that inherits the **LNS** class, and add a public function **Larger_nodes** to return the result of the above question.

def test_run(content1): return SN_LNS(content1).Larger_nodes()

test_run

assert candidate([["class LNS", "def __init__(self, head)", "class SN_LNS(LNS)", "super().__init__(head)", "def Larger_nodes"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/117

Question: Given a binary matrix grid of size m x n, where 0 represents an ocean cell and 1 represents a land cell. A move is defined as moving from one land cell to another adjacent (up, down, left, right) land cell or crossing the border of the **grid**. Return the number of land cells in the grid that cannot leave the grid border in any number of moves; Please create a class **LCL** in Python based on the above question, with the attribute **grid**. Then create a class **SN_LCL** that inherits from the **LCL** class, and add a public function **Land_Cell** to return the number of land cells in the grid that cannot leave the grid border in any number of moves.

def test_run(content1): return SN_LCL(content1).Land_Cell()

test_run

assert candidate([["class LCL", "def __init__(self, grid)", "class SN_LCL(LCL)", "super().__init__(grid)", "def Land_Cell"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/118

Question: Given a string array **queries** and a string representing a **pattern**, return a boolean array **answer**. Only when the query item queries[i] matches the pattern string pattern, answer[i] is True, otherwise it is False; Based on the above question, please create a class **BAY** in Python with the property **queries**; then create a class **SN_BAY** that inherits from the **BAY** class, and add the property **pattern**, as well as a public function **boolean_array** that returns the above results.

def test_run(content1,content2): return SN_BAY(content1,content2).boolean_array()

test_run

assert candidate([["class BAY", "def __init__(self, queries)", "class SN_BAY(BAY)", "def __init__(self, queries, pattern)", "super().__init__(queries)", "def boolean_array"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/119

Question: Given an integer array **nums**, return the length of the longest arithmetic subsequence in **nums**; Based on the above question, create a class **LSQ** using Python language, with the attribute **nums**. Then create another class **SN_LSQ**, inheriting from the **LSQ** class, and add a public function **Longest_subsequence** to return the length of the longest arithmetic subsequence in the integer array **nums**.

def test_run(content1): return SN_LSQ(content1).Longest_subsequence()

test_run

assert candidate([["class LSQ", "def __init__(self, nums)", "class SN_LSQ(LSQ)", "super().__init__(nums)", "def Longest_subsequence"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/120

Question: The company plans to interview 2n people. Given an array **costs**, where costs[i]=[aCosti,bCosti]. The cost for the i-th person to fly to city **a** is **aCost_i**, and the cost to fly to city **b** is **bCost_i**. Return the minimum cost to fly each person to either city **a** or **b**, with the requirement that **n** people must arrive in each city; Based on the above question, create a class **MCT** in Python language with the attribute **costs**; then create a class **SN_MCT** that inherits from the **MCT** class, and add a public function **Minimum_cost** to return the result of the above question.

def test_run(content1): return SN_MCT(content1).Minimum_cost()

test_run

assert candidate([["class MCT", "def __init__(self, costs)", "class SN_MCT(MCT)", "super().__init__(costs)", "def Minimum_cost"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/121

Question: Given an integer array **nums** and two integers **firstLen** and **secondLen**, you are to find and return the maximum sum of elements in two non-overlapping subarrays, with lengths respectively as **firstLen** and **secondLen**; Based on the above question, create a class **OSR** in Python with the attribute **nums**; then create another class **SN_OSR** that inherits from the **OSR** class, and add two attributes **firstLen** and **secondLen**, as well as a public function **overlapping_subarray** that returns the result of the above question.

def test_run(content1,content2,content3): return SN_OSR(content1,content2,content3).overlapping_subarray()

test_run

assert candidate([["class OSR", "def __init__(self, nums)", "class SN_OSR(OSR)", "def __init__(self, nums, firstLen, secondLen)", "super().__init__(nums)", "def overlapping_subarray"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/122

Question: Three stones are placed on the number line at positions **a**, **b**, and **c**. In each round, you can pick up a stone from one of the ends (either the largest or smallest position) and place it in any free position between the two ends. Formally, suppose the three stones are currently at positions **x**, **y**, and **z** with x<y<z. Then you can pick up a stone from position **x** or **z** and move it to an integer position **k**, where x<k<z and k!=y. The game ends when you can't make any more moves, i.e., when the positions of the stones are consecutive. What are the minimum and maximum number of moves you can make to end the game? Return the answer in the form of a 2-length array: answer=[minimum_moves,maximum_moves]; Based on the above question, please create a class **SMT** in Python with an attribute **a**; then create a class **SN_SMT** that inherits from the **SMT** class, and add two attributes **b** and **c**, as well as a public function **Stone_movement** that returns the result of the above question.

def test_run(content1,content2,content3): return SN_SMT(content1,content2,content3).Stone_movement()

test_run

assert candidate([["class SMT", "def __init__(self, a)", "class SN_SMT(SMT)", "def __init__(self, a, b, c)", "super().__init__(a)", "def Stone_movement"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/123

Question: Write down the integers in **nums1** and **nums2** in the given order on two independent horizontal lines. Now, some lines can be drawn connecting the two numbers nums1[i] and nums2[j]. These lines need to satisfy the following conditions: 1. nums1[i] == nums2[j]; 2. The drawn line does not intersect with any other lines (non-horizontal lines). Please note that the lines cannot intersect even at the endpoints: each number can only belong to one line. Draw lines in this way and return the maximum number of lines that can be drawn. Please create a class called **MCT** in Python, which has the attribute **nums1**. Then create another class called **SN_MCT** that inherits from the **MCT** class, and add the attribute **nums2**, as well as a public function **max_connections** that returns the maximum number of lines that can be drawn.

def test_run(content1,content2): return SN_MCT(content1,content2).max_connections()

test_run

assert candidate([["class MCT", "def __init__(self, nums1)", "class SN_MCT(MCT)", "def __init__(self, nums1, nums2)", "super().__init__(nums1)", "def max_connections"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/124

Question: In a 10^6x10^6 grid, the coordinates of each cell are (x,y). Now, starting from the source cell source=[sx,sy], the intention is to rush to the target cell target=[tx,ty]. The array blocked is a list of blocked cells, where each blocked[i]=[xi,yi] indicates that the cell with coordinates (xi,yi) is forbidden to pass. Each move can go to the cell adjacent in the four directions in the grid, as long as the cell is not on the given **blocked** list. Also, it is not allowed to go out of the grid. Only when it is possible to reach the target cell target from the source cell source through a series of moves, return True. Otherwise, return False; Based on the above question, please create a class **SGD** in Python language with the attribute **blocked**; then create a class **SN_SGD**, inherit the **SGD** class, and add two attributes **source** and **target**, and a public function **Source_grid** to return the result of the above question.

def test_run(content1,content2,content3): return SN_SGD(content1,content2,content3).Source_grid()

test_run

assert candidate([["class SGD", "def __init__(self, blocked)", "class SN_SGD(SGD)", "def __init__(self, blocked, source, target)", "super().__init__(blocked)", "def Source_grid"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/125

Question: You have a convex n-polygon, each vertex of which has an integer value. Given an integer array **values**, where values[i] is the value of the i-th vertex (i.e., in clockwise order). Assume the polygon is divided into n-2 triangles. For each triangle, the value of the triangle is the product of the vertex labels, and the score of the triangulation is the sum of the values of all n-2 triangles after the triangulation. Return the lowest score that can be obtained after the polygon is triangulated; Based on the above question, please create a class **TGT** in Python, with the attribute **values**; then create a class **SN_TGT** that inherits from the **TGT** class, and add a public function **triangulation** that returns the lowest score that can be obtained after the polygon is triangulated.

def test_run(content1): return SN_TGT(content1).triangulation()

test_run

assert candidate([["class TGT", "def __init__(self, values)", "class SN_TGT(TGT)", "super().__init__(values)", "def triangulation"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/126

Question: On an infinite plane, the robot initially stands at the point (0,0), facing north. Note: 1. North is the positive direction of the y-axis. 2. South is the negative direction of the y-axis. 3. East is the positive direction of the x-axis. 4. West is the negative direction of the x-axis. The robot can accept one of the following three instructions: 1. **G**: Go straight for 1 unit. 2. **L**: Turn left by 90 degrees. 3. **R**: Turn right by 90 degrees. The robot executes the **instructions** in order and repeats them indefinitely. Only when there is a loop in the plane that the robot can never leave, return True. Otherwise, return False; Please create a class **EIT** in Python based on the above problem, with the property **instructions**; Then create a class **SN_EIT**, inheriting from the **EIT** class, and add a public function **Execute_instructions** to return the result of the above problem.

def test_run(content1): return SN_EIT(content1).Execute_instructions()

test_run

assert candidate([["class EIT", "def __init__(self, instructions)", "class SN_EIT(EIT)", "super().__init__(instructions)", "def Execute_instructions"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/127

Question: There are **n** gardens, labeled from 1 to **n**. There is also an array **paths**, where paths[i] = [x_i, y_i] describes the bidirectional path from garden **x_i** to garden **y_i**. In each garden, you plan to plant one of four types of flowers. Moreover, each garden can have at most three paths leading in or out. You need to choose a type of flower for each garden so that the types of flowers in any two gardens connected by a path are different. Return any feasible solution as the answer **answer** in the form of an array, where answer[i] represents the type of flower planted in the (i+1)th garden. The types of flowers are represented by 1, 2, 3, and 4; Based on the above question, create a class **PFS** in Python with the attribute **n**; then create a class **SN_PFS** that inherits from the **PFS** class, and add the attribute **paths**, as well as a public function **Planted_flowers** that returns the result of the above question.

def test_run(content1,content2): return SN_PFS(content1,content2).Planted_flowers()

test_run

assert candidate([["class PFS", "def __init__(self, n)", "class SN_PFS(PFS)", "def __init__(self, n, paths)", "super().__init__(n)", "def Planted_flowers"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/128

Question: Given an integer array **arr**, please divide this array into some (continuous) sub-arrays with a maximum length of **k**. After the division, all values in each sub-array will become the maximum value in that sub-array. Return the maximum sum of elements that can be obtained after the array is divided and transformed; Based on the above question, create a class **STF** in Python language with the attribute **arr**; then create a class **SN_STF** that inherits the **STF** class, and add the attribute **k**, as well as a public function **Separation_transformation** that returns the maximum sum of elements that can be obtained after the array is divided and transformed.

def test_run(content1,content2): return SN_STF(content1,content2).Separation_transformation()

test_run

assert candidate([["class STF", "def __init__(self, arr)", "class SN_STF(STF)", "def __init__(self, arr, k)", "super().__init__(arr)", "def Separation_transformation"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/129

Question: Given a string **s**, consider all its repeated substrings: that is, the (continuous) substrings of **s** that appear 2 or more times in **s**. These appearances may overlap. Return any one of the possible longest repeated substrings. If **s** does not contain repeated substrings, then the answer is ""; Please create a class **RST** in Python language based on the above question, with the attribute **s**; then create another class **SN_RST** that inherits from the **RST** class, and add a public function **Repeated_substring** that returns the possible longest repeated substring.

def test_run(content1): return SN_RST(content1).Repeated_substring()

test_run

assert candidate([["class RST", "def __init__(self, s)", "class SN_RST(RST)", "super().__init__(s)", "def Repeated_substring"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/130

Question: Given a word array **words**, each word is composed of lowercase English letters. If we can add exactly one letter anywhere in **wordA** without changing the order of other characters to make it become **wordB**, then we consider **wordA** to be the predecessor of **wordB**. For example, **abc** is the predecessor of **abac**, while **cba** is not the predecessor of **bcad**. A word chain is a sequence composed of words [word_1, word_2, ..., word_k], k>=1, where **word1** is the predecessor of **word2**, **word2** is the predecessor of **word3**, and so on. A word is usually a word chain where k==1. Choose words from the given word list **words** to form a word chain, and return the longest possible length of the word chain; Based on the above question, please create a class **FCA** in Python with the attribute **words**; then create another class **SN_FCA** that inherits from the **FCA** class, and add a public function **Form_chain** that returns the longest possible length of the word chain.

def test_run(content1): return SN_FCA(content1).Form_chain()

test_run

assert candidate([["class FCA", "def __init__(self, words)", "class SN_FCA(FCA)", "super().__init__(words)", "def Form_chain"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/131

Question: There is a pile of stones, represented by an integer array **stones**. Where stones[i] represents the weight of the i-th stone. Each round, select any two stones from it and crush them together. Suppose the weights of the stones are **x** and **y**, and x <= y. Then the possible results of crushing are as follows: 1. If x == y, then both stones will be completely crushed; 2. If x != y, then the stone with weight **x** will be completely crushed, and the new weight of the stone with weight **y** is y-x. In the end, at most one stone will be left. Return the minimum possible weight of this stone. If no stones are left, return 0; Based on the above question, please create a class **MWG** in Python, with the property **stones**; then create a class **SN_MWG** that inherits from the **MWG** class, and add a public function **Minimum_weight** to return the result of the above question.

def test_run(content1): return SN_MWG(content1).Minimum_weight()

test_run

assert candidate([["class MWG", "def __init__(self, stones)", "class SN_MWG(MWG)", "super().__init__(stones)", "def Minimum_weight"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/132

Question: Given a positive integer array **arr** (which may contain duplicate elements), please return the maximum arrangement that is lexicographically smaller than **arr** and can be obtained by one swap (swapping the positions of two numbers arr[i] and arr[j]). If such operation is not possible, please return the original array; Based on the above question, create a class **OEH** in Python with the attribute **arr**. Then create another class **SN_OEH** that inherits from the **OEH** class, and add a public function **One_exchange** that returns the result of the above question.

def test_run(content1): return SN_OEH(content1).One_exchange()

test_run

assert candidate([["class OEH", "def __init__(self, arr)", "class SN_OEH(OEH)", "super().__init__(arr)", "def One_exchange"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/133

Question: In a warehouse, there is a row of barcodes, where the i-th barcode is barcodes[i]. Please rearrange these barcodes so that no two adjacent barcodes are the same. You can return any answer that meets this requirement, and it is guaranteed that an answer exists; Please create a class **ABD** in Python based on the above question, with the property **barcodes**; then create a class **SN_ABD** that inherits from the **ABD** class, and add a public function **Adjacent_barcodes** that returns the result of the above question.

def test_run(content1): return SN_ABD(content1).Adjacent_barcodes()

test_run

assert candidate([["class ABD", "def __init__(self, barcodes)", "class SN_ABD(ABD)", "super().__init__(barcodes)", "def Adjacent_barcodes"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/134

Question: Given two strings of equal length, **s1** and **s2**, and another string, baseStr, where s1[i] and s2[i] are a pair of equivalent characters. For example, if s1 = **abc** and s2 = **cde**, then 'a' == 'c', 'b' == 'd', and 'c' == 'e'. Equivalent characters follow the general rules of any equivalence relation: 1. Reflexivity: 'a' == 'a'; 2. Symmetry: if 'a' == 'b', then 'b' == 'a'; 3. Transitivity: if 'a' == 'b' and 'b' == 'c', then 'a' == 'c'. Using the equivalence information of **s1** and **s2**, find and return the lexicographically smallest equivalent string of baseStr; Based on the above question, please create a class **EST** in Python, with the attribute **s1**; then create another class **SN_EST**, inheriting from the **EST** class, and add two attributes **s2** and **baseStr**, as well as a public function **Equivalent_String** that returns the lexicographically smallest equivalent string of **baseStr**.

def test_run(content1,content2,content3): return SN_EST(content1,content2,content3).Equivalent_String()

test_run

assert candidate([["class EST", "def __init__(self, s1)", "class SN_EST(EST)", "def __init__(self, s1, s2, baseStr)", "super().__init__(s1)", "def Equivalent_String"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/135

Question: Given an m x n matrix **matrix**, you can select any number of columns from it and flip each cell on it. (That is, after flipping, the value of the cell changes from 0 to 1, or from 1 to 0.) Return the maximum number of rows where all values in the row are equal after some flips; Please create a class **MRW** with the property **matrix** in Python based on the above question; then create a class **SN_MRW** that inherits the **MRW** class, and add a public function **Maximum_rows** to return the result of the above question.

def test_run(content1): return SN_MRW(content1).Maximum_rows()

test_run

assert candidate([["class MRW", "def __init__(self, matrix)", "class SN_MRW(MRW)", "super().__init__(matrix)", "def Maximum_rows"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/136

Question: Given two numbers **arr1** and **arr2** in base -2, return the result of their addition; Please create a class named **ANS** in Python based on the above question, with the attribute **arr1**. Then create another class named **SN_ANS**, which inherits from the **ANS** class, and adds the attribute **arr2**, as well as a public function **Adding_Numbers** to return the result of adding the two numbers.

def test_run(content1,content2): return SN_ANS(content1,content2).Adding_Numbers()

test_run

assert candidate([["class ANS", "def __init__(self, arr1)", "class SN_ANS(ANS)", "def __init__(self, arr1, arr2)", "super().__init__(arr1)", "def Adding_Numbers"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/137

Question: Given a **matrix** and a **target** value, return the number of non-empty submatrices whose sum of elements equals the target value; Please create a class **ESI** in Python language based on the above question, with the attribute **matrix**; then create another class **SN_ESI**, inheriting from the **ESI** class, and add the attribute **target**, as well as a public function **empty_submatrix** to return the number of non-empty submatrices whose sum of elements equals the **target** value.

def test_run(content1,content2): return SN_ESI(content1,content2).empty_submatrix()

test_run

assert candidate([["class ESI", "def __init__(self, matrix)", "class SN_ESI(ESI)", "def __init__(self, matrix, target)", "super().__init__(matrix)", "def empty_submatrix"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/138

Question: You have a set of movable type **tiles**, each of which is engraved with a letter tiles[i]. Return the number of non-empty letter sequences you can print; Please create a class **LSQ** based on the above question, with the attribute **tiles** using Python language; then create another class **SN_LSQ**, inheriting from the **LSQ** class, and add a public function **letter_sequence** that returns the number of non-empty letter sequences that can be printed.

def test_run(content1): return SN_LSQ(content1).letter_sequence()

test_run

assert candidate([["class LSQ", "def __init__(self, tiles)", "class SN_LSQ(LSQ)", "super().__init__(tiles)", "def letter_sequence"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/139

Question: Return the subsequence of **s** with the smallest lexicographical order, which contains all distinct characters of **s** and only contains them once; Based on the above question, create a class **SSU** in Python language with the attribute **s**. Then create another class **SN_SSU**, which inherits from the **SSU** class, and add a public function **smallest_subsequence** to return the result of the above question.

def test_run(content1): return SN_SSU(content1).smallest_subsequence()

test_run

assert candidate([["class SSU", "def __init__(self, s)", "class SN_SSU(SSU)", "super().__init__(s)", "def smallest_subsequence"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/140

Question: We have a set of **n** items. Two integer arrays, **values** and **labels**, are given, where the value and label of the i-th element are values[i] and labels[i] respectively. Two more integers, **numWanted** and **useLimit**, are also given. We are to select a subset **s** from the **n** elements such that: 1. The size of subset **s** is less than or equal to numWanted. 2. There are at most useLimit items with the same label in **s**. The score of a subset is the sum of the values of the subset. The task is to return the maximum score of subset **s**; Based on the above question, please create a class named **MSR** in Python, which has the attribute **values**. Then create another class **SN_MSR**, which inherits from the **MSR** class, and adds three attributes: **labels**, **numWanted**, and **useLimit**, as well as a public function **Maximum_score** that returns the maximum score of subset **s**.

def test_run(content1,content2,content3,content4): return SN_MSR(content1,content2,content3,content4).Maximum_score()

test_run

assert candidate([["class MSR", "def __init__(self, values)", "class SN_MSR(MSR)", "def __init__(self, values, labels, numWanted, useLimit)", "super().__init__(values)", "def Maximum_score"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/141

Question: Given an n x n binary matrix **grid**, return the length of the shortest unobstructed path in the matrix. If such a path does not exist, return -1; Based on the above question, please create a **UPT** class in Python with a **grid** attribute; then create a **SN_UPT** class that inherits the **UPT** class, and add a public **Unobstructed_path** function to return the result of the above question.

def test_run(content1): return SN_UPT(content1).Unobstructed_path()

test_run

assert candidate([["class UPT", "def __init__(self, grid)", "class SN_UPT(UPT)", "super().__init__(grid)", "def Unobstructed_path"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/142

Question: Given two strings **str1** and **str2**, return the shortest string that has both **str1** and **str2** as subsequences; Please create a class **SSI** in Python, which has the attribute **str1**. Then create another class **SN_SSI** that inherits from the **SSI** class, and add the attribute **str2**, as well as a public function **Shortest_string** to return the shortest string that has both **str1** and **str2** as subsequences.

def test_run(content1,content2): return SN_SSI(content1,content2).Shortest_string()

test_run

assert candidate([["class SSI", "def __init__(self, str1)", "class SN_SSI(SSI)", "def __init__(self, str1, str2)", "super().__init__(str1)", "def Shortest_string"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/143

Question: Initially, there are **capacity** empty seats on the bus. The bus can only travel in one direction (that is, it is not allowed to turn around or change direction). Given the integer **capacity** and an array **trips**, trip[i] = [numPassengers_i, from_i, to_i] indicates that there are **numPassengers_i** passengers in the i-th trip, and their pick-up and drop-off locations are **from_i** and **to_i** respectively. These locations are the kilometers from the initial position of the car to the east. Return True only and only when you can pick up and drop off all passengers in all given trips, otherwise please return False; Based on the above question, please create a class **PPG** using Python language, with the attribute **trips**; then create a class **SN_PPG** that inherits the **PPG** class, and add the attribute **capacity**, and a public function **Pick_passengers** that returns the result of the above question.

def test_run(content1,content2): return SN_PPG(content1,content2).Pick_passengers()

test_run

assert candidate([["class PPG", "def __init__(self, trips)", "class SN_PPG(PPG)", "def __init__(self, trips, capacity)", "super().__init__(trips)", "def Pick_passengers"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/144

Question: Given a mountain array **mountainArr**, please return the smallest index **index** that makes mountainArr.get(index) equal to **target**. If there is no such index **index**, please return -1. What is a mountain array? If array **A** is a mountain array, then it satisfies the following conditions: 1. A.length>=3; 2. Under the condition of 0<i<A.length-1, there exists i such that: A[0]<A[1]<...A[i-1]<A[i]; A[i]>A[i+1]>...>A[A.length-1]; Based on the above question, please use Python language to create a class **MAR** with the property **array**; then create a class **SN_MAR** that inherits the **MAR** class, and add the property **target**, as well as a public function **Mountain_array** that returns the result of the above question.

def test_run(content1,content2): return SN_MAR(content1,content2).Mountain_array()

test_run

assert candidate([["class MAR", "def __init__(self, array)", "class SN_MAR(MAR)", "def __init__(self, array, target)", "super().__init__(array)", "def Mountain_array"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/145

Question: Given a boolean expression **expression** in string form, return the result of the operation. A boolean expression is an expression whose result is either True or False. Valid expressions must follow the following conventions: 1. 't', the operation result is True; 2. 'f', the operation result is False; 3. '!(subExpr)', the operation process is to perform logical NOT operation on the internal expression subExpr; 4. '&(subExpr1,subExpr2,...,subExprn)', the operation process is to perform logical AND operation on two or more internal expressions subExpr1, subExpr2,...,subExprn; 5. '|(subExpr1,subExpr2,...,subExprn)', the operation process is to perform logical OR operation on two or more internal expressions subExpr1, subExpr2,...,subExprn; Based on the above question, please create a class **BLS** in Python with the attribute **expression**. Then create another class **SN_BLS** that inherits from the **BLS** class, and add a public function **Booleans** to return the result of the above question.

def test_run(content1): return SN_BLS(content1).Booleans()

test_run

assert candidate([["class BLS", "def __init__(self, expression)", "class SN_BLS(BLS)", "super().__init__(expression)", "def Booleans"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/146

Question: Here we have **n** flights, numbered from 1 to **n**. There is a flight booking sheet **bookings**. The i-th booking record in the sheet, bookings[i]=[firsti,lasti,seatsi], means that **seatsi** seats have been booked on each flight from **firsti** to **lasti** (including **firsti** and **lasti**). Please return an array **answer** of length **n**, where each element is the total number of seats booked for each flight; Based on the above question, please create a class **RSA** in Python language with the attribute **bookings**; then create a class **SN_RSA** that inherits from the **RSA** class, and add the attribute **n**, as well as a public function **Reserved_seats** that returns the result of the above question.

def test_run(content1,content2): return SN_RSA(content1,content2).Reserved_seats()

test_run

assert candidate([["class RSA", "def __init__(self, bookings)", "class SN_RSA(RSA)", "def __init__(self, bookings, n)", "super().__init__(expression)", "def Reserved_seats"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/147

Question: Given a work schedule **hours**, which records the daily working hours of an employee. We consider that if the working hours of an employee in a day exceed 8 hours, then this day is a tiring day. The so-called good performance period means that during this period, the number of tiring days is strictly greater than the number of non-tiring days. Please return the maximum length of the good performance period; Please create a **PWL** class in Python based on the above question, with the attribute **hours**; then create a **SN_PWL** class that inherits the **PWL** class, and add a public **Performing_well** function to return the maximum length of the good performance period.

def test_run(content1): return SN_PWL(content1).Performing_well()

test_run

assert candidate([["class PWL", "def __init__(self, hours)", "class SN_PWL(PWL)", "super().__init__(hours)", "def Performing_well"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/148

Question: As a project manager, you have planned a list of required skills **req_skills**, and intend to select some people from the list of alternative personnel **people** to form a **necessary team** (the alternative personnel numbered **i**, people[i], has a list of skills that this alternative personnel masters). The so-called necessary team is a team in which, for each skill listed in the required skill list **req_skills**, at least one member of the team has already mastered it. The team members can be represented by the numbers of each person: please return any necessary team of the smallest scale, with the team members represented by the personnel numbers. You can return the answer in any order, and the question data guarantees that the answer exists; Please create a class **NTM** in Python based on the above question, with the attribute **req_skills**; then create a class **SN_NTM** that inherits the **NTM** class, and add the attribute **people**, as well as a public function **Necessary_team** that returns the result of the above question.

def test_run(content1,content2): return SN_NTM(content1,content2).Necessary_team()

test_run

assert candidate([["class NTM", "def __init__(self, req_skills)", "class SN_NTM(NTM)", "def __init__(self, req_skills, people)", "super().__init__(req_skills)", "def Necessary_team"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/149

Question: Given an integer **n**, which is the number of nodes in a directed graph, where the nodes are labeled from 0 to n-1. Each edge in the graph is either red or blue, and there may be self-loops or parallel edges. Given two arrays **redEdges** and **blueEdges**, where: 1. redEdges[i]=[a_i,b_i] represents that there is a red directed edge from node **a_i** to node **b_i** in the graph, 2. **blueEdges[j]=[u_j,v_j]** represents that there is a blue directed edge from node **u_j** to node **v_j** in the graph. Return an array **answer** of length **n**, where answer[X] is the length of the shortest path from node 0 to node **X** with alternating appearances of red and blue edges. If such a path does not exist, then answer[x]=-1; Please create a class **AAR** with the attribute **n** using Python based on the above question; then create a class **SN_AAR** that inherits the **AAR** class, and add two attributes **red_edges** and **blue_edges**, as well as a public function **Alternating_appearance** that returns the result of the above question.

def test_run(content1,content2,content3): return SN_AAR(content1,content2,content3).Alternating_appearance()

test_run

assert candidate([["class AAR", "def __init__(self, n)", "class SN_AAR(AAR)", "def __init__(self, n, red_edges, blue_edges)", "super().__init__(n)", "def Alternating_appearance"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/150

Question: Given two integer arrays of equal length, return the maximum value of the following expression: |arr1[i]-arr1[j]|+|arr2[i]-arr2[j]|+|i-j| where the indices **i**, **j** satisfy 0<=i,j<arr1.length; Based on the above question, please create a class **MES** in Python, which has the attribute **arr1**. Then create another class **SN_MES**, inheriting from the **MES** class, and add the attribute **arr2**, as well as a public function **Maximum_expression** to return the result of the above question.

def test_run(content1,content2): return SN_MES(content1,content2).Maximum_expression()

test_run

assert candidate([["class MES", "def __init__(self, arr1)", "class SN_MES(MES)", "def __init__(self, arr1, arr2)", "super().__init__(arr1)", "def Maximum_expression"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/151

Question: Given a two-dimensional **grid** composed of several 0s and 1s, please find the largest square sub-grid whose boundaries are all composed of 1s, and return the number of elements in the sub-grid. If it does not exist, return 0; Please create a class **SSR** with the property **grid** in Python based on the above question; then create a class **SN_GGG** that inherits from the **GGG** class, and add a public function **Square_subgrid** to return the result of the above question.

def test_run(content1): return SN_GGG(content1).Square_subgrid()

test_run

assert candidate([["class SSR", "def __init__(self, grid)", "class SN_GGG(GGG)", "super().__init__(grid)", "def Square_subgrid"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/152

Question: Alice and Bob continue their stone game. Many piles of stones are lined up, each pile has a positive integer number of stones piles[i]. The game is decided by who has the most stones in their hands. Alice and Bob take turns, with Alice starting first. Initially, M=1. In each player's turn, the player can take all the stones from the remaining first **X** piles, where 1<=X<=2M. Then, let M=max(M,X). The game continues until all the stones are taken. Assuming Alice and Bob both play at their best, return the maximum number of stones Alice can get; Based on the above question, please create a class **SGA** using Python language, with the attribute **piles**; then create a class **SN_SGA** that inherits the **SGA** class, and add a public function **Stone_Game** to return the maximum number of stones Alice can get.

def test_run(content1): return SN_SGA(content1).Stone_Game()

test_run

assert candidate([["class SGA", "def __init__(self, piles)", "class SN_SGA(SGA)", "super().__init__(piles)", "def Stone_Game"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/153

Question: Given two strings **text1** and **text2**, return the length of the longest common subsequence of these two strings. If there is no common subsequence, return 0. A subsequence of a string is a new string that is formed by deleting some characters (or no characters) from the original string without changing the relative order of the characters. The common subsequence of two strings is a subsequence that the two strings both have; Based on the above question, please create a class **SSN** in Python, with the attribute **text1**; then create another class **SN_SSN** that inherits from the **SSN** class, and add the attribute **text2**, as well as a public function **Shared_subsequences** to return the result of the above question.

def test_run(content1,content2): return SN_SSN(content1,content2).Shared_subsequences()

test_run

assert candidate([["class SSN", "def __init__(self, text1)", "class SN_SSN(SSN)", "def __init__(self, text1, text2)", "super().__init__(text1)", "def Shared_subsequences"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/154

Question: Given an integer array **nums**, each operation will select an element and decrease its value by 1. If one of the following conditions is met, then array **A** is a zigzag array: 1. Each element corresponding to an even index is greater than its adjacent elements, i.e., A[0]>A[1]<A[2]>A[3]<A[4]>...; 2. Or, each element corresponding to an odd index is greater than its adjacent elements, i.e., A[0]<A[1]>A[2]<A[3]>A[4]<...; Return the minimum number of operations required to convert the array **nums** into a zigzag array. Based on the above question, please create a class **JAR** in Python language, which has the attribute **nums**. Then create a class **SN_JAR** that inherits from the **JAR** class, and add a public function **Jagged_array** to return the minimum number of operations required to convert the integer array **nums** into a zigzag array.

def test_run(content1): return SN_JAR(content1).Jagged_array()

test_run

assert candidate([["class JAR", "def __init__(self, nums)", "class SN_JAR(JAR)", "super().__init__(nums)", "def Jagged_array"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/155

Question: You will be given a string **text**, which should be divided into **k** substrings (subtext1, subtext2,…,subtextk), with the following requirements: 1. Each **subtexti** is a non-empty string; 2. The concatenation of all substrings equals to **text** (i.e., subtext1+subtext2+...+subtextk==text); 3. For all valid values of **i** (i.e., 1<=i<=k), subtexti==subtextk-i+1 should hold True; The task is to return the maximum possible value of **k**. Please create a class **ESI** in Python, which has the attribute **text**. Then create another class **SN_ESI**, which inherits from the **ESI** class, and add a public function **empty_string** that returns the maximum possible value of **k**.

def test_run(content1): return SN_ESI(content1).empty_string()

test_run

assert candidate([["class ESI", "def __init__(self, text)", "class SN_ESI(ESI)", "super().__init__(text)", "def empty_string"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/156

Question: Here we have **n** identical dice, each with **k** faces, numbered from 1 to **k**. Given three integers **n**, **k**, and **target**, return the number of possible ways (out of a total of k^n ways) to roll the dice so that the sum of the numbers facing up equals **target**; Based on the above question, please create a class **FUP** in Python, with the attribute **n**; then create another class **SN_FUP**, inheriting from the **FUP** class, and add two attributes **k** and **target**, as well as a public function **face_up** that returns the result of the above question.

def test_run(content1,content2,content3): return SN_FUP(content1,content2,content3).face_up()

test_run

assert candidate([["class FUP", "def __init__(self, n)", "class SN_FUP(FUP)", "def __init__(self, n, k, target)", "super().__init__(n)", "def face_up"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/157

Question: If all characters in a string are the same, then the string is a single-character repeated string. Given a string **text**, you can only swap two characters once or do nothing, and then get some single-character repeated substrings. Return the length of the longest substring; Please create a **DSN** class in Python based on the above question, with the attribute **text**. Then create a class **SN_DSN** that inherits from the **DSN** class, and add a public function **Duplicate_string** that returns the length of the longest substring.

def test_run(content1): return SN_DSN(content1).Duplicate_string()

test_run

assert candidate([["class DSN", "def __init__(self, text)", "class SN_DSN(DSN)", "super().__init__(text)", "def Duplicate_string"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/158

Question: You currently have a **grid** of size n x n in your hand, with each cell marked with 0 and 1. Here, 0 represents the ocean, and 1 represents the **land**. Please find an ocean cell where the distance to the nearest land cell is the maximum, and return this distance. If the grid only contains land or ocean, please return -1; Based on the above question, create an **OCL** class in Python language with the **grid** attribute; then create a **SN_OCL** class that inherits the **OCL** class, and add a public **Ocean_Cell** function to return the result of the above question.

def test_run(content1): return SN_OCL(content1).Ocean_Cell()

test_run

assert candidate([["class OCL", "def __init__(self, grid)", "class SN_OCL(OCL)", "super().__init__(grid)", "def Ocean_Cell"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/159

Question: Given a string **s**, find all its substrings and sort them in lexicographical order, return the last substring; Based on the above question, create a class **LAM** in Python language with the attribute **s**; then create another class **SN_LAM**, inheriting from the **LAM** class, and add a public function **Lexicographic_arrangement** to return the last substring.

def test_run(content1): return SN_LAM(content1).Lexicographic_arrangement()

test_run

assert candidate([["class LAM", "def __init__(self, s)", "class SN_LAM(LAM)", "super().__init__(s)", "def Lexicographic_arrangement"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/160

Question: A transaction may be invalid under the following two circumstances: 1. The transaction amount exceeds $1000; 2. Or, it is not more than 60 minutes (including 60 minutes) apart from another transaction with the same name in another city; Given the string array transaction list **transactions**. Each transaction string transactions[i] is composed of some values separated by commas, which represent the name, time (in minutes), amount, and city of the transaction. Return **transactions**, return the list of possible invalid transactions; Please create a class **TLI** in Python language based on the above question, with the attribute **transactions**; then create another class **SN_TLI** that inherits from the **TLI** class, and add a public function **Transaction_List** that returns the result of the above question.

def test_run(content1): return SN_TLI(content1).Transaction_List()

test_run

assert candidate([["class TLI", "def __init__(self, transactions)", "class SN_TLI(TLI)", "super().__init__(transactions)", "def Transaction_List"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/161

Question: Given two integer arrays **arr1** and **arr2**, return the minimum number of operations required to make **arr1** strictly increasing (possibly 0). In each operation, you can select an index from both **arr1** and **arr2**, respectively **i** and **j**, where 0<=i<arr1.length and 0<=j<arr2.length, and then perform the assignment operation arr1[i]=arr2[j]. If it is impossible to make **arr1** strictly increasing, please return -1; Based on the above question, please create a class **SII** in Python language with the property **arr1**; then create another class **SN_SII** that inherits the **SII** class, and add the property **arr2**, as well as a public function **Strictly_Increasing** that returns the result of the above question.

def test_run(content1,content2): return SN_SII(content1,content2).Strictly_Increasing()

test_run

assert candidate([["class SII", "def __init__(self, arr1)", "class SN_SII(SII)", "def __init__(self, arr1, arr2)", "super().__init__(arr1)", "def Strictly_Increasing"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/162

Question: Given a string **s** (containing only lowercase English letters and parentheses), please reverse the string in each pair of matching parentheses from the inside out in order, and return the final result; Based on the above question, please create a class **MBC** in Python language with the attribute **s**. Then create another class **SN_MBC** that inherits from the **MBC** class, and add a public function **Match_Brace** to return the final result.

def test_run(content1): return SN_MBC(content1).Match_Brace()

test_run

assert candidate([["class MBC", "def __init__(self, s)", "class SN_MBC(MBC)", "super().__init__(s)", "def Match_Brace"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/163

Question: Given an integer array **arr** and an integer **k**, modify the array by repeating **k** times. Return the sum of the largest subarray in the modified array; Please create a class **SSA** in Python based on the above question, with the attribute **arr**. Then create a class **SN_SSA** that inherits from the **SSA** class, and add the attribute **k**, as well as a public function **Sum_subarrays** that returns the sum of the largest subarray in the modified array.

def test_run(content1,content2): return SN_SSA(content1,content2).Sum_subarrays()

test_run

assert candidate([["class SSA", "def __init__(self, arr)", "class SN_SSA(SSA)", "def __init__(self, arr, k)", "super().__init__(k)", "def Sum_subarrays"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/164

Question: Given four integers: **n**, **a**, **b**, **c**, please design an algorithm to find the n-th ugly number; Based on the above question, create a class **UNB** in Python, with the attribute **n**; then create another class **SN_UNB**, inheriting from the **UNB** class, and add three attributes **a**, **b** and **c**, as well as a public function **Ugly_number** to return the n-th ugly number.

def test_run(content1,content2,content3,content4): return SN_UNB(content1,content2,content3,content4).Ugly_number()

test_run

assert candidate([["class UNB", "def __init__(self, n)", "class SN_UNB(UNB)", "def __init__(self, n, a, b, c)", "super().__init__(n)", "def Ugly_number"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/165

Question: Given a string **s** and some index pairs array **pairs** in the string, where pairs[i]=[a,b] represents two indexes in the string (numbered from 0). You can swap the characters at any pair of indexes in pairs any number of times. Return the lexicographically smallest string that **s** can become after several swaps; Based on the above question, please create a class **DMM** in Python with the attribute **s**; then create a class **SN_DMM** that inherits the **DMM** class, and add the attribute **pairs**, as well as a public function **Dictionary_minimum** to return the result of the above question.

def test_run(content1,content2): return SN_DMM(content1,content2).Dictionary_minimum()

test_run

assert candidate([["class DMM", "def __init__(self, s)", "class SN_DMM(DMM)", "def __init__(self, s, pairs)", "super().__init__(s)", "def Dictionary_minimum"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/166

Question: Given two strings of equal length, **s** and **t**. Changing the i-th character in **s** to the i-th character in **t** requires a cost of |s[i]-t[i]| (the cost could be 0), which is the absolute difference of the ASCII values of the two characters. The maximum budget for changing the string is **maxCost**. During the string transformation, the total cost should be less than or equal to this budget, which also means that the string transformation may be incomplete. If you can transform a substring of **s** into its corresponding substring in **t**, then return the maximum length that can be transformed. If there is no substring in **s** that can be transformed into a corresponding substring in **t**, then return 0; Based on the above question, please create a class named **MBG** in Python, which has an attribute **s**. Then create a class named **SN_MBG**, which inherits from the **MBG** class, and adds two attributes **t** and **maxCost**, as well as a public function **Maximum_budget** to return the result of the above question.

def test_run(content1,content2,content3): return SN_MBG(content1,content2,content3).Maximum_budget()

test_run

assert candidate([["class MBG", "def __init__(self, s)", "class SN_MBG(MBG)", "def __init__(self, s, t, maxCost)", "super().__init__(s)", "def Maximum_budget"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/167

Question: Given a string **s**, the **k** times repeated item deletion operation will select **k** adjacent and equal letters from **s** and delete them, connecting the left and right sides of the deleted string. You need to repeatedly perform such deletion operations on **s** indefinitely until it can no longer continue. After all deletion operations are completed, return the final obtained string; Based on the above question, please create a class **DOT** in Python language with the attribute **s**; then create a class **SN_DOT**, inherit the **DOT** class, and add the attribute **k**, as well as a public **Delete_Operation** function to return the final obtained string.

def test_run(content1,content2): return SN_DOT(content1,content2).Delete_Operation()

test_run

assert candidate([["class DOT", "def __init__(self, s)", "class SN_DOT(DOT)", "def __init__(self, s, k)", "super().__init__(s)", "def Delete_Operation"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False

OOP/168

Question: Given an integer array **arr** and an integer **difference**, please find and return the length of the longest arithmetic subsequence in **arr**, where the difference between adjacent elements equals **difference**; Based on the above question, please create a class **ESQ** in Python, which has the attribute **arr**. Then create another class **SN_ESQ**, inheriting from the **ESQ** class, and add the attribute **difference**, as well as a public function **Equidistant_subsequence** to return the length of the longest arithmetic subsequence in the integer array **arr**.

def test_run(content1,content2): return SN_ESQ(content1,content2).Equidistant_subsequence()

test_run

assert candidate([["class ESQ", "def __init__(self, arr)", "class SN_ESQ(ESQ)", "def __init__(self, arr, difference)", "super().__init__(arr)", "def Equidistant_subsequence"]]) == True

def matching_function(content): def run_match(text): for task in text: if task not in str_content: return False return True len_cont = len(content) if len_cont==1 and run_match(content[0]) == True: return True elif (len_cont==2 and run_match(content[0]) == True) or (len_cont==2 and run_match(content[1]) == True): return True else: return False