Python 我需要帮助找到一个智能解决方案，以缩短此代码运行的时间

两天前，我开始在Codewars.com上练习Python2.7，我遇到了一个非常有趣的问题，唯一的问题是我认为这对我的python知识水平来说有点太高了。事实上，我最终解决了这个问题，但该网站不接受我的解决方案，因为当你用大量数字调用它时，需要花费太多的时间才能完成，所以下面是代码：

from itertools import permutations
def next_bigger(n):
    digz =list(str(n))
    nums =permutations(digz, len(digz))
    nums2 = []

    for i in nums:
        z =''
        for b in range(0,len(i)):
            z += i[b]

        nums2.append(int(z))

    nums2 = list(set(nums2))
    nums2.sort()
    try:
        return nums2[nums2.index(n)+1]
    except:
        return -1

“您必须创建一个函数，该函数接受一个正整数，并返回由相同数字组成的下一个较大的数字”-这些是原始指令

也有一次，我决定放弃整个排列思想，在第二次尝试的过程中，我意识到它是不可能工作的：

def next_bigger(n):
for i in range (1,11):
    c1 = n % (10**i) / (10**(i-1))
    c2 = n % (10**(i+1)) / (10**i)

    if c1 > c2:
        return ((n /(10**(i+1)))*10**(i+1)) + c1 *(10**i) + c2*(10**(i-1)) + n % (10**(max((i-1),0)))
        break

---

如果有人有任何想法，我洗耳恭听，如果你讨厌我的代码，请告诉我，因为我真的想在这方面做得更好。

这个怎么样？有关解释，请参阅联机注释。请注意，按照这种设置方式，最终不会有任何显著的内存使用（我们不会存储任何列表）

如果您的代码需要更快，那么您需要一个更智能、非暴力的算法。

“由相同的数字组成”-有一个线索，您必须将数字分解为数字：

n=list（str（n））

“下一个更大”。事实上，他们想要的是下一个项目，这意味着你想做最少的改变。专注于改变1s数字。如果这不起作用，请尝试10位，然后是100位，等等。您可以做的最小更改是将两个最远的数字交换到右边，这将增加整数的值。即，交换最右边的两个数字，其中最右边的数字越大

def next_bigger(n):
    n = list(str(n))
    for i in range(len(n)-1, -1, -1):
        for j in range(i-1, -1, -1):
            if n[i] > n[j]:
                n[i], n[j] = n[j], n[i]
                return int("".join(n))

print next_bigger(123)

哎呀。对于

next\u biger（1675）

，此操作失败。我将把错误代码留在这里一段时间，不管它值多少钱。

从

下面是关于下一个更大数字的一些观察结果

1） 如果所有数字都按降序排序，则输出总是“不可能”。例如，4321

2） 如果所有数字都按升序排序 订单，然后我们需要交换最后两位数字。例如，1234

3） 为了 其他情况下，我们需要从最右边处理数字（为什么？ 因为我们需要找到所有大数字中最小的一个）

您现在可以尝试自己开发一个算法

下面是查找下一个较大数字的算法

(一) 从最右边的数字开始遍历给定的数字，一直遍历到 您会发现一个比先前遍历的数字小的数字。 例如，如果输入的数字是“534976”，那么我们在4处停止，因为4 小于下一位数字9。如果我们没有找到这样一个数字，那么 输出是“不可能的”

二） 现在在上面找到的数字“d”的右侧搜索 大于“d”的最小数字。对于“534976”，4的右侧 包含“976”。大于4的最小数字是6

三） 交换上面找到的两个数字，我们在上面的例子中得到536974

四） 现在将所有数字从“d”旁边的位置排序到 编号。排序后得到的编号就是输出。对于上面的 例如，我们以粗体536974对数字进行排序，得到“536479”，这是 下一个更大的数字用于输入534976

---

你不需要看所有的排列。看最后两个数字的两个排列。如果你有一个整数大于你的整数，那就是了。如果没有，看最后三个数字的排列，等等

from itertools import permutations


def next_bigger(number):

    check = 2
    found = False
    digits = list(str(number))

    if sorted(digits, reverse=True) == digits:
        raise ValueError("No larger number")

    while not found:
        options = permutations(digits[-1*check:], check)
        candidates = list()
        for option in options:
            new = digits.copy()[:-1*check]
            new.extend(option)
            candidate = int(''.join(new))
            if candidate > number:
                candidates.append(candidate)
        if candidates:
            result = sorted(candidates)[0]
            found = True
            return result

        check += 1

---

这比他的实现要快多少？我不认为暴力解决这个问题（速度太慢）…但我可能错了

def next_bigger(n):
    n = list(str(n))
    for i in range(len(n)-1, -1, -1):
        for j in range(i-1, -1, -1):
            if n[i] > n[j]:
                n[i], n[j] = n[j], n[i]
                return int("".join(n))

print next_bigger(123)

from itertools import permutations


def next_bigger(number):

    check = 2
    found = False
    digits = list(str(number))

    if sorted(digits, reverse=True) == digits:
        raise ValueError("No larger number")

    while not found:
        options = permutations(digits[-1*check:], check)
        candidates = list()
        for option in options:
            new = digits.copy()[:-1*check]
            new.extend(option)
            candidate = int(''.join(new))
            if candidate > number:
                candidates.append(candidate)
        if candidates:
            result = sorted(candidates)[0]
            found = True
            return result

        check += 1