Python子列表元素规则校验函数报错，寻求正确实现方案

First, let’s restate the requirements clearly to align on what the function needs to do:
The function takes a list of 2-element sublists (e.g., lis=[[1,2],[3,4],[5,9],[6,8]]) and returns a boolean based on these rules:

1. Rule 1: If any sublist has both values strictly greater than another sublist’s both values → return True.
   • Example: [1,2] and [3,4] (3>1 and 4>2) triggers this rule.
2. Rule 2: If Rule 1 isn’t satisfied, check if there’s at least one consecutive pair where the next sublist’s first value is strictly greater than the previous, and its second value is strictly smaller than the previous → return True if such a pair exists, else False.
   • Example: [5,9] and [6,8] (6>5 and 8<9) triggers this rule if Rule 1 wasn’t met.

Common Issues in the Original Function #

Most likely, your original code had one or more of these problems:

• Only checking consecutive pairs for Rule 1 instead of all possible pairs of sublists.
• Checking Rule 2 before Rule 1 (violating the priority of the rules).
• Off-by-one errors when iterating over consecutive pairs for Rule 2.

Corrected Function Implementation #

Here’s a working version of the ORDER_LINK function that follows the rules correctly:

def ORDER_LINK(lis):
    # Check Rule 1: Any sublist is completely larger than another
    num_sublists = len(lis)
    for i in range(num_sublists):
        for j in range(num_sublists):
            if i != j:
                # Verify if lis[i] is strictly larger than lis[j] on both elements
                if lis[i][0] > lis[j][0] and lis[i][1] > lis[j][1]:
                    return True
    
    # If Rule 1 fails, check Rule 2: Consecutive pair with first increasing, second decreasing
    for k in range(num_sublists - 1):
        current = lis[k]
        next_sub = lis[k+1]
        if next_sub[0] > current[0] and next_sub[1] < current[1]:
            return True
    
    # Neither rule is satisfied
    return False

Explanation of the Code #

1. Rule 1 Check:
   • We use nested loops to compare every distinct pair of sublists. As soon as we find a pair where one sublist is fully larger than the other, we return True immediately.
2. Rule 2 Check:
   • If Rule 1 wasn’t triggered, we loop through consecutive sublist pairs. We check if the next sublist’s first element is bigger than the previous, and its second element is smaller. If found, return True.
3. Fallback:
   • If neither rule is satisfied after all checks, return False.

Testing the Function #

Let’s validate with your example list:

lis = [[1,2],[3,4],[5,9],[6,8]]
print(ORDER_LINK(lis))  # Returns True (triggers Rule 1: [3,4] > [1,2])

Test case where Rule 1 fails but Rule 2 passes:

lis2 = [[2,3],[4,2],[5,1]]
print(ORDER_LINK(lis2))  # Returns True (Rule 2: [4,2] and [5,1])

Test case where neither rule is met:

lis3 = [[1,3],[2,4],[3,5]]
print(ORDER_LINK(lis3))  # Returns False (all pairs have increasing elements, no full larger sublist)

内容的提问来源于stack exchange，提问作者Ahmad Aziz