数字减少的最小数字

Question

我发现了一个实现函数的问题，该函数接受一个正整数n作为输入并返回大于n的最小正整数，该正整数的位数在减小，而对于返回大于n的最小正整数的函数，其正整数又递增。 我认为增加功能可以正常工作。 但是函数减少有什么错误呢？ 对于减少的输入（100），它返回11而不是110。

# the next integer whose digits are increasing.
def increasing(n):
    asastring = str(n)
    length = len(asastring)
    if asastring == "9"*length:
        return "1"*(length+1)
    if length == 1:
        return int(n)+1

    if length >= 2:
        firstcharacter = asastring[0]
        secondcharacter = asastring[1]
        if int(firstcharacter) > int(secondcharacter):
            return int(str(firstcharacter)*length)
        if firstcharacter == secondcharacter:
             return firstcharacter+str(increasing(int(asastring[1:])))
        if int(firstcharacter) < int(secondcharacter):
            if secondcharacter == "9":
                return str(int(firstcharacter)+1) * len(str(n))
            return firstcharacter+str(increasing(int(asastring[1:])))

# the next integer whose digits are decreasing.
def decreasing(n):
    asastring = str(n)
    length = len(asastring)
# First the case where we need to add a digit.
    if asastring == "9"*length:
        return "1"+"0"*length
# Now we know that the next integer has the same number of digits as the original number.
    if length == 1:
        return int(n)+1
    if length >= 2:
        firstcharacter = asastring[0]
        secondcharacter = asastring[1]
        if int(firstcharacter) > int(secondcharacter):
            endpart = str(((asastring[1:3])))
            value = firstcharacter + str(decreasing(int(asastring[1:])))
            return str(firstcharacter) + str(decreasing(int(asastring[1:])))
        if int(firstcharacter) == int(secondcharacter):
            return decreasing(firstcharacter+str(decreasing(int(asastring[1:]))))
        if int(firstcharacter) < int(secondcharacter):
            return str(int(firstcharacter)+1)+'0'*(length-1)

i=100
print(increasing(i))
print(decreasing(i))

Answer 1

您需要删除在递归调用中完成的int类型转换，因为int（'00'）将您的数字转换为零（基本上删除了所有开头的零）并缩短了字符串的长度。 只需删除该转换即可。.其余代码工作正常：

def decreasing(n):
    asastring = str(n)
    length = len(asastring)
# First the case where we need to add a digit.
    if asastring == "9"*length:
        return "1"+"0"*length
# Now we know that the next integer has the same number of digits as the original number.
    if length == 1:
        return int(n)+1
    if length >= 2:
        firstcharacter = asastring[0]
        secondcharacter = asastring[1]
        if int(firstcharacter) > int(secondcharacter):
            return str(firstcharacter) + str(decreasing(asastring[1:]))
        if int(firstcharacter) == int(secondcharacter):
            return decreasing(firstcharacter+str(decreasing(asastring[1:])))
        if int(firstcharacter) < int(secondcharacter):
            return str(int(firstcharacter)+1)+'0'*(length-1)

Answer 2

有多个相互交织的问题需要解决。 这两个功能的命名令人困惑。 如果我们遵循逻辑，则函数increasing()应称为nondecreasing() ，类似地，函数decreasing()应称为nonincreasing() 。 >（大于）和> =（大于或等于）之间的区别。

下一个困惑是这些函数接受并返回哪种类型？ 如果我们检查工作中的 increasing()函数返回的内容，则会得到：

str return "1"*(length+1)
int return int(n)+1
int return int(str(firstcharacter)*length)
str return firstcharacter+str(increasing(int(asastring[1:])))
str return str(int(firstcharacter)+1) * len(str(n))
str return firstcharacter+str(increasing(int(asastring[1:])))

如果我们类似地查看increasing()如何处理其自身的内部递归调用，以查看其认为接受和返回的内容，则会得到：

int -> int  return firstcharacter+str(increasing(int(asastring[1:])))
int -> int  return firstcharacter+str(increasing(int(asastring[1:])))

因此，这里尝试了increasing() ，又称为nondecreasing()重做，试图使其始终接受一个int并返回一个int ：

def nondecreasing(n):  # aka increasing()
    as_string = str(n)
    length = len(as_string)

    if as_string == "9" * length:
        return int("1" * (length + 1))

    if length == 1:
        return int(n) + 1

    first_digit, second_digit, second_digit_onward = as_string[0], as_string[1], as_string[1:]

    if first_digit > second_digit:
        return int(first_digit * length)

    if first_digit == second_digit:
        return int(first_digit + str(nondecreasing(int(second_digit_onward))))

    if as_string == first_digit + "9" * (length - 1):
        return int(str(int(first_digit) + 1) * length)

    return int(first_digit + str(nondecreasing(int(second_digit_onward))))

decreasing() aka nonincreasing()函数的问题更大。 它依靠接受int或内部调用的str来解决问题的能力。

讨论这些问题，而不是让其他程序员重新发现它们，是代码注释的全部内容。

我不认为上述问题会阻止nonincreasing()始终返回 int ：

def nonincreasing(n):  # aka decreasing()
    as_string = str(n)
    length = len(as_string)

    if as_string == "9" * length:
        return int("1" + "0" * length)

    if length == 1:
        return int(n) + 1

    first_digit, second_digit, second_digit_onward = as_string[0], as_string[1], as_string[1:]

    if first_digit > second_digit:
        return int(first_digit + str(nonincreasing(second_digit_onward)))

    if first_digit == second_digit:
        remaining_digits = str(nonincreasing(second_digit_onward))
        second_digit = remaining_digits[0]
        n = first_digit + remaining_digits

    if first_digit < second_digit:
        return int(str(int(first_digit) + 1) + '0' * (length - 1))

    return int(n)

修复此功能的关键是从倒数第二个if子句中删除return语句，而是修复数据，然后让它进入下一个if子句，以查看结果是否需要修复。

我相信@ devender22对int()强制转换的见解是至关重要的，但是我不认为随附的解决方案是有效的，因为它会生成大量错误结果（例如，从990到998到1000时它们都应该被简单地撞掉） 1）。

为了检查我的nonincreasing()函数的所有情况，我使用完全不同的Python运算符编写了一个效率较低，非递归的解决方案，没有单独的情况：

def nonincreasing(n):

    def is_increasing(n):
        string = str(n)

        return any(map(lambda x, y: y > x, string, string[1:]))

    while is_increasing(n + 1):
        n += 1

    return n + 1

然后确保两个实现在其输出上达成一致。