Python笔记 | 卡布列克常数

朴灿烈づ我的快乐病毒、 2024-03-30 12:39 20阅读 0赞

**文章目录**

**0x00 前言**

**0x01 问题分析**

**0x02 代码设计**

**0x03 代码流程**

**0x04 完整代码**

**0x05 运行效果**

**0x06 参考文献**

**0x07 总结**

--------------------

#### 0x00 前言 ####

> 任意一个不是由完全相同数字组成的四位数，如果对它们的每位数字重新排序，组成一个较大的数和一个较小的数，然后用较大数减去较小数，差不够四位数时补零，类推下去，最后将变成一个固定的数：6174，这就是卡布列克常数。

#### 0x01 问题分析 ####

关于卡布列克常数给出以下示例：

从给出的示例可见，卡布列克常数就是任意一个由不是完全相同的数字组成的四位数，然后将组成的最大值减去最小值，不断重复后，得到的数都是一个固定的数：6174。

#### 0x02 代码设计 ####

def ad_define(n):
        ad = [0] * 4    #ad-Array Data
        ad[0] = n // 1000
        ad[1] = (n % 1000) // 100
        ad[2] = ((n % 1000) % 100) // 10
        ad[3] = ((n % 1000) % 100) % 10
        return ad

**代码解析：**使用 def 声明一个函数 ad\_define(n) ，参数 n 为用户输入的数据，定义变量 ad 用来保存四位整数上的每位数，ad 表示数组数据的简写，ad\[0\] 数组用来保存千位上的数，ad\[1\] 数组用来保存百位上的数，ad\[2\] 数组用来保存十位上的数，ad\[3\] 数组用来保存个位上的数，最后使用 return() 函数返回。

def ad_max(ad):
        for i in range(0, len(ad) - 1):
            for j in range(0, len(ad) - 1 - i):
                if ad[j] <= ad[j + 1]:
                    ad[j], ad[j + 1] = ad[j + 1], ad[j]
        max = "".join(list(map(lambda x: str(x), ad)))
        max = int(max)
        return max    #max 最大值

**代码解析：**使用 def 声明一个函数 data\_max 求出卡布列克常数的最大值，算法使用冒泡排序排序出这组数据的最大值。因为后续减法必须采用整数形式计算，所以需要给 max 变量的数组类型转换为字符串类型，这里使用 lambda() 函数将参数 ad 设置为字符串形式。 map() 函数用作映射，代码中的 join 方法主要用于字符串的拼接，最后使用 return 函数返回到 max 中。注意，一个函数需要使用 return 返回值才算有效，否则函数无效。

def ad_min(ad):
        for i in range(0, len(ad) - 1):
            for j in range(0, len(ad) - 1 - i):
                if ad[j] >= ad[j + 1]:
                    ad[j], ad[j + 1] = ad[j + 1], ad[j]
        min = "".join(list(map(lambda x: str(x), ad)))
        min = int(min)
        return min    #min最小值

**代码解析：**使用 def 声明一个函数 data\_min 求出卡布列克常数的最小值，算法使用冒泡排序排序出这组数据的最小值。因为后续减法必须采用整数形式计算，所以需要给 min 变量的数组类型转换为字符串类型，这里使用 lambda() 函数将参数 ad 设置为字符串形式。 map() 函数用作映射，代码中的 join 方法主要用于字符串的拼接，最后使用 return 函数返回到 min 中。注意，一个函数需要使用 return 返回值才算有效，否则函数无效。

def kblk(n, count):
        if n != 6174 and n != 0:
            ad = ad_define(n)
            max = ad_max(ad)
            min = ad_min(ad)
            num = max - min
            count += 1
            print(f'{count}:{max}-{min}={num}')
            kblk(num, count)

**代码解析：**定义一个 kblk() 函数，使用 if 判断语句判断变量 n 中的数据，如果变量 n 不等于 6174 和 0 ，那么则执行一次卡布列克常数的计算。使用 ad\_define(n) 函数将处理好的数据存储到变量 ad 中，注意此时数据类型为数组类型，接着将处理好的数据发送给 ad\_max() 函数用来计算数据的最大值，将处理好的数据发送给 ad\_min() 函数用来计算数据的最小值。将最大值减去最小值则完成一次卡布列克常数的计算，将数据保存在变量 num 中。使用 count += 1 为变量 count 记录这次卡布列克常数的计算。然后使用 print() 函数打印出这一次卡布列克常数的计算。最后在将计算后的数据保存在 kblk() 函数中。

def main():
        n = int(input("输入一个4位整数："))
        count = 0    #计数
        while n >= 1000 and n <= 9998:
            kblk(n, count)    #kblk-卡布列克
            break
    main()

**代码解析：**定义一个 main() 函数，用于执行验证卡布列克常数的代码。获取用户的输入，提示用户输入内容必须为一个 4 位数的整数，使用 int() 整数形式的方法保留数据到变量 n 中。定义一个变量 count ，并设置初始值 0 作为卡布列克常数计算执行步骤的计数。使用一个 while 循环判断用户输入的这个数，如果这个数大于等于 1000 和 小于等于 9998 ，那么执行函数 kblk() 并用 break 语句跳出循环。最后使用 main() 函数执行。

#### 0x03 代码流程 ####

![a031648086474f2e98e6b591abf24aeb.png][] 代码运行流程图

#### 0x04 完整代码 ####

def ad_define(n):
        ad = [0] * 4
        ad[0] = n // 1000
        ad[1] = (n % 1000) // 100
        ad[2] = ((n % 1000) % 100) // 10
        ad[3] = ((n % 1000) % 100) % 10
        return ad
    
    def ad_max(ad):
        for i in range(0, len(ad) - 1):
            for j in range(0, len(ad) - 1 - i):
                if ad[j] <= ad[j + 1]:
                    ad[j], ad[j + 1] = ad[j + 1], ad[j]
        max = "".join(list(map(lambda x: str(x), ad)))
        max = int(max)
        return max
    
    def ad_min(ad):
        for i in range(0, len(ad) - 1):
            for j in range(0, len(ad) - 1 - i):
                if ad[j] >= ad[j + 1]:
                    ad[j], ad[j + 1] = ad[j + 1], ad[j]
        min = "".join(list(map(lambda x: str(x), ad)))
        min = int(min)
        return min
    
    def kblk(n, count):
        if n != 6174 and n != 0:
            ad = ad_define(n)
            max = ad_max(ad)
            min = ad_min(ad)
            num = max - min
            count += 1
            print(f'{count}:{max}-{min}={num}')
            kblk(num, count)
    
    if __name__ == "__main__":
        n = int(input("输入一个4位整数："))
        count = 0
        while n >= 1000 and n <= 9998:
            kblk(n, count)
            break

#### 0x05 运行效果 ####

请输入一个4位整数：9876
    1:9876-6789=3087
    2:8730-378=8352
    3:8532-2358=6174
    
    Process finished with exit code 0

#### 0x06 参考文献 ####

> \[1\].百度百科. 卡布列克常数\[EB/OL\]. \[2022-12-28\]. https://baike.baidu.com/item/%E5%8D%A1%E5%B8%83%E5%88%97%E5%85%8B%E5%B8%B8%E6%95%B0/3177243.
> 
> \[2\].刘河飞. 趣学Python算法100例\[M\]. 机械工业出版社, 2020.

#### 0x07 总结 ####

文章内容为学习记录的笔记，由于作者水平有限，文中若有错误与不足欢迎留言，便于及时更正。

[a031648086474f2e98e6b591abf24aeb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/25a4466ddb7f4a1aa9ca1461c6da1ff3.png