最多应用一次交换操作以获得严格递增序列

我正在网上的各个网站上做一些 DS&A 问题进行练习，我遇到了这个问题：

给定一个非负整数数组，您可以从此数组中选择任何数字并交换其中的任意两位数字。如果在交换操作之后数字包含前导零，则可以省略它们并且不考虑它们。您的任务是检查是否可以最多应用一次交换操作，以便结果数组的元素严格增加。

出于某种原因，这让我一开始感到困惑，所以我去了健身房并思考了一会儿。最终我回过头来再次尝试，这次找到了解决方案。不幸的是，我得到的解决方案有点丑陋和笨重，我感觉这不是解决这个问题的好方法。它适用于我尝试过的测试，但我真的想为此找到更好的解决方案。我觉得我一定缺少一些可以改善它的基本东西。

所以我在这里发布我的代码希望得到一些反馈。

def solution(numbers):

    swaps = 0
    index = 0
    for i in range(len(numbers)-1):
        if numbers[i] >= numbers[i+1]:
            swaps+=1
            index=i
    if swaps > 1:
        return False
    elif not swaps:
        return True

    swappedI = swapToSmallest(numbers[index])
    if (index-1 < 0 or numbers[index-1] < swappedI) and numbers[index+1] > swappedI:
        return True
    swappedIPlus1 = swapToSmallest(numbers[index])
    if (index+1 > len(numbers) or numbers[index+1] < swappedIPlus1) and numbers[index-1] < swappedIPlus1:
        return True

    return False
    

def swapToSmallest(num) -> int:
    num = str(num)
    smallIndex = 0
    smallestRight = num[smallIndex]
    for i in range(1, len(num)):
        if num[i] <= smallestRight:
            smallestRight = num[i]
            smallIndex = i

    largeIndex = -1
    largeLeft = num[largeIndex]
    for i in range(len(num)-2, -1, -1):
        if num[i] >= largeLeft:
            largeLeft = num[i]
            largeIndex = i

    res = ""
    for i, v in enumerate(num):
        if i == largeIndex:
            res+=smallestRight
        elif i == smallIndex:
            res+=largeLeft
        else:
            res+=v


    return int(res)

    

#tests            
numbers = [1, 5, 10, 20]
print(solution(numbers))

numbers = [1, 3, 900, 10]
print(solution(numbers))

numbers = [1000, 10, 100]
print(solution(numbers))

numbers = [1, 2, 10, 7]
print(solution(numbers))

numbers = [1, 3, 3, 3]
print(solution(numbers))

numbers = [1000, 10, 9]
print(solution(numbers))

肯定有更简单的解决方案。例如，这是我想出的一个（只是尝试一下，我确信还有更优化的解决方案）：

def flip(i):
    return int(''.join(str(i)[::-1]))


def strict_inc(xs, single_flip_allowed=True):
    for n, (a, b) in enumerate(zip(xs, xs[1:])):
        if a >= b:
            break
    else:
        return True
    # here, n will be the index at which the first problem occurs
    return single_flip_allowed and (
        (
            (n == 0 or xs[n-1] < flip(xs[n]))
            and (n == len(xs) or flip(xs[n]) < xs[n+1])
            and strict_inc(xs[n+1:], False)
        )
        or
        (
            (xs[n] < flip(xs[n+1]))
            and (n+1 == len(xs) or flip(xs[n+1]) < xs[n+2])
            and strict_inc(xs[n+2:], False)
        )
    )

（请注意，这实现了您的解决方案，并添加了翻转，但不是正确的解决方案，请继续阅读）

尽管该函数会递归调用自身，但它不会多次调用自身，因此不会出现任何问题。

它基本上工作的前提是原始正整数序列中只能有一个缺陷。因此，它找到第一个缺陷，查看是否可以通过“翻转”缺陷中的第一个或第二个整数来修复它，并检查在这种情况下序列的其余部分是否仍然严格增加（不允许进一步翻转）。

您要求对您的代码进行审查，但鉴于它显然远非最佳，因此全面完成这将是一项艰巨的任务。

如果您确实想要评论，我建议您尝试https://codereview.stackexchange.com/因为StackOverflow确实更适合寻求具体技术问题的解决方案。

事实证明（感谢@barmar 指出我的错误，并感谢@kellybundy 指出OP 的错误），一个有效的解决方案也不是那么复杂（同样有改进的空间）：

def check(xs):
    x = str(xs[1])
    return any(xs[0] < int(f'{x[0:i]}{x[j]}{x[i+1:j]}{x[i]}{x[j+1:]}') < xs[2]
               for i in range(len(x)) for j in range(i+1, len(x)))


def strict_inc(xs, single_flip_allowed=True):
    for n, (a, b) in enumerate(zip(xs, xs[1:])):
        if a >= b:
            break
    else:
        return True
    # here, n will be the index at which the first problem occurs
    return single_flip_allowed and (
        (
            check(xs[n-1:n+2] if n > 0 else [-1] + xs[n:n+2])
            and strict_inc(xs[n+1:], False)
        )
        or
        (
            check(xs[n:n+3] if n < len(xs)-2 else xs[n:n+2] + [int('9'*len(str(xs[n+1])))])
            and strict_inc(xs[n+2:], False)
        )
    )

（另一个编辑：这个解决方案实际上根据需要尝试所有可能的配对）