python刷题—转换编程思想到python！

最新推荐文章于 2025-06-06 11:42:41 发布

wonengguwozai

最新推荐文章于 2025-06-06 11:42:41 发布

阅读量889

点赞数

CC 4.0 BY-SA版权

分类专栏：刷刷题

本文链接：https://blog.youkuaiyun.com/wonengguwozai/article/details/78869932

刷刷题专栏收录该内容

62 篇文章

订阅专栏

本文解析了包括不重复三位数计算、水仙花数查找、完全数判断、相亲数求解等在内的多个经典编程题目，并提供了Python实现代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、0~9这10个数字可以组成多少不重复的3位数？（三个数都不一样）

#-*-coding:utf-8-*-

num = 0
for i in range(100,1000):
    if str(i)[0] != str(i)[1] and str(i)[0] != str(i)[2] and str(i)[1] != str(i)[2]:
        num += 1

print("可以组成",num,"个不重复的数字")

2、水仙花数（自幂数）

水仙花数是指一个n位数（n≥3），它的每个位上的数字的n次幂之和等于它本身。
例如：1^3+5^3+3^3=153。

求100~999之间所有的水仙花数。

#-*-coding:utf-8-*- list_num = [] for i in range(100, 1000): i_1 = i % 10 i_2 = i % 100 / 10 i_3 = i / 100 if i == i_1 ** 3 + i_2 ** 3 + i_3 ** 3: list_num.append(i) else: pass print("100-1000所有的水仙花数为", list_num)

3、

完全数（Perfect number)，又称完美数或完备数，是一些特殊的自然数。它所有的真因子(即除了自身以外的约数）的和（即因子函数），恰好等于它本身。例如，第一个完全数是6，它有约数1、2、3、6，除去它本身6外，其余3个数相加，1+2+3=6。第二个完全数是28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。

编程求10000以内的完全数。

（上方注释部分我自己实现，下方我pythonic版的实现，学习思路和python思想！）

#-*-coding:utf-8-*- ''' import numpy as np perfect_list = [] for i in range(1,10001): list_i = [1] sum_i = 0 for j in range(2,int(np.sqrt(i)) + 1): for k in range(j,i + 1): if j * k == i: list_i.append(j) list_i.append(k) else: pass for value in list_i: sum_i += value if sum_i == i: perfect_list.append(i) else: pass print("10000以内完全数有：", perfect_list) ''' list_num = [] num = 10000 for i in range(1,num + 1): if (sum([j for j in range(1,i) if i % j == 0])) == i: list_num.append(i) print("10000以内完全数有", list_num)

4、相亲数

220的真因数之和为1+2+4+5+10+11+20+22+44+55+110=284
284的真因数之和为1+2+4+71+142=220
毕达哥拉斯把这样的数对A、B称为相亲数：A的真因数之和为B，而B的真因数之和为A。

求100000以内的相亲数。

#-*-coding:utf-8-*-
date_list = []
num = 10000
for i in range(1,num):
    dict_date = {}
    data2 = sum([j for j in range(1,i) if i % j == 0])
    if i == sum([k for k in range(1, data2) if data2 % k == 0]):
        dict_date[i] = data2
        #剔除掉结果中键和值相等的字典对和两个字典变量中键和值互为相等中的一个（{220: 284}, {284: 220}）
        if i < data2:
            date_list.append(dict_date)
        else:
            pass
    else:
        pass

print("between 1 to 10000's date number are: ", date_list)

5、

黑洞数

黑洞数又称陷阱数，是类具有奇特转换特性的整数。任何一个数字不全相同的整数，经限“重排求差”操作，总会得到某一个或一些数，这些数即为黑洞数。“重排求差”操作即把组成该数的数字重排后得到的最大数减去重排后得到的最小数。
举个例子，3位数的黑洞数为495.
简易推导过程：随便找个数，如297,3个位上的数从小到大和从大到小各排一次，为972和279，相减得693。按上面做法再做一次，得到594，再做一次，得到495，之后反复都得到495。

验证4位数的黑洞数为6174。

我的代码：

import random from itertools import permutations bite_num = 5 flag = str(random.randint(10000,99999)) list_num = [] for i in range(bite_num): list_num.append(flag.strip()[i]) permu_list = list(permutations(list_num, bite_num)) for i, index in enumerate(permu_list,0): temp = "".join(index) permu_list[i] = int(temp) result = str(max(permu_list) - min(permu_list)) while flag != result: flag = result list_num = [] for i in range(bite_num): list_num.append(flag.strip()[i]) permu_list = list(permutations(list_num, bite_num)) for i, index in enumerate(permu_list,0): temp = "".join(index) permu_list[i] = int(temp) result = str(max(permu_list) - min(permu_list)) print("四位数的黑洞数为：", result)

更pythonic的代码：

import random def func(n): a = [int(i) for i in str(n)] a.sort() s1 = reduce(lambda x, y : 10 * x + y, a[::-1]) s2 = reduce(lambda x, y : 10 * x + y, a) return n if s1 - s2 == n else func(s1 - s2) n = str(random.randint(1000,10000)) print("res:", func(n))

6、杨式矩阵：在一个m行n列二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

#-*-coding:utf-8-*-
def find(l, key):
    m = len(l)
    n = len(l[0])
    i = 0
    j = n - 1
    while i < m and j > 0:
        if l[i][j] == key:
            #注意python的格式化输出
            print("find the number in %d row,%d col" % (i ,j))
            return
        elif l[i][j] < key:
            i += 1
        else:
            j -= 1
    print ("have not the key!")

if __name__ == "__main__":
    arr = [[1, 3, 5, 7],[2, 4, 6, 8],[9, 10, 11, 12]]
    find(arr, 134)

7、

去除列表中的重复元素（保持列表元素顺序不变）

#-*coding:utf-8-*-

'''
#使用集合并保持元素顺序
l = ["1", "2","a", 3, 4, "1", "2"]
d = list(set(l))
re = sorted(d, key = l.index)
print re
'''

#使用列表推导式方式，注意列表推导式未必在最左侧要生成一个值！
l = ["1", "2","a", 3, 4, "1", "2"]
ll = []
res = [ll.append(i) for i in l if not i in ll]
print res

8、

合并两个有序列表

下面是自己写的代码

l1 = [1, 2, 3, 4, 9, 23, 778]
l2 = [3, 4, 5, 7, 23, 100]

l3 = []
while len(l1) > 0 or len(l2) > 0:
    if len(l1) <= 0:
        l3.append(l2.pop(0))#pop()函数可以指定从第一个位置弹出元素
    elif len(l2) <= 0:
        l3.append(l1.pop(0))
    elif l1[0] < l2[0]:
        l3.append(l1.pop(0))
    elif l1[0] > l2[0]:
        l3.append(l2.pop(0))
    elif l1[0] == l2[0]:
        l3.append(l1.pop(0))
        l2.pop(0)

print l3

局部改进后：

#-*-coding:utf-8-*- l1 = [1, 2, 3, 4, 9, 23, 778] l2 = [3, 4, 5, 7, 23, 100] l3 = [] while len(l1) > 0 or len(l2) > 0: if len(l1) <= 0: #l3.append(l2.pop(0)) #pop()函数可以指定从第一个位置弹出元素 l3.extend(l2) #使用extend()函数可一次性将原列表在后端拓展 l2 = [] elif len(l2) <= 0: #l3.append(l1.pop(0)) l3.extend(l1) l1 = [] elif l1[0] < l2[0]: l3.append(l1.pop(0)) elif l1[0] > l2[0]: l3.append(l2.pop(0)) elif l1[0] == l2[0]: l3.append(l1.pop(0)) l2.pop(0) print l3

递归形式

#-*-coding:utf-8-*- l1 = [1, 2, 3, 4, 9, 23, 778] l2 = [3, 4, 5, 7, 23, 100] def _recursion_merge_sort2(l1, l2, tmp): if len(l1) == 0 or len(l2) == 0: tmp.extend(l1) tmp.extend(l2) return tmp else: if l1[0] < l2[0]: tmp.append(l1[0]) del l1[0] else: tmp.append(l2[0]) del l2[0] return _recursion_merge_sort2(l1, l2, tmp) print _recursion_merge_sort2(l1, l2, [])

9、

交叉链表求交点

其实思想可以按照从尾开始比较两个链表，如果相交，则从尾开始必然一致，只要从尾开始比较，直至不一致的地方即为交叉点，如图所示

方法一（化为列表法）：

def find_node(l1, l2):
    """
    This function find the cross node between two list

    :param l1: this param is the first list of input
    :param l2: this param is the second list of input
    :returns: it will return the cross node of two list
    """
    cross = 0
    while len(l1) > 0 and len(l2) > 0:
        temp = l1.pop()
        if temp == l2.pop():
            cross = temp
        else:
            return cross

a = [1, 2, 3, 6, 7, 8]
b = [12, 34, 44, 4, 6, 7, 8]

print find_node(a ,b)

方法二（构建列表法）：

class List_Node(object):
    def __init__(self):
        self.val = None
        self.nex = None

class List_Handle(object):
    def __init__(self):
        self.cur_node = None

    def add_node(self, data):
        new_node = List_Node()
        new_node.val = data
        new_node.nex = self.cur_node
        self.cur_node = new_node

    def get_len(self):
        len = 0
        fist_node = self.cur_node
        while self.cur_node.nex != None:
            self.cur_node = self.cur_node.nex
            len += 1
        self.cur_node = fist_node
        return len
def find(l1, l2):
    l1_node = l1.cur_node
    l2_node = l2.cur_node
    len1 = l1.get_len()
    len2 = l2.get_len()
    if len1 > len2:
        for _ in range(1, len1 - len2):
            l1_node = l1_node.nex
    elif len1 < len2:
        for _ in range(len2 - len1):
            l2_node = l2_node.nex

    while l1_node.nex != None:
        if l1_node.val != l2_node.val:
            l1_node = l1_node.nex
            l2_node = l2_node.nex
        else:
            print l1_node.val, "is the cross node"
            return

val1 = [1 , 2, 55,  3, 4]
val2 = [23, 44, 55, 3, 4]
val1.reverse()
val2.reverse()
ln1 = List_Handle()
ln2 = List_Handle()
for v in val1:
    ln1.add_node(v)
for v in val2:
    ln2.add_node(v)

find(ln1, ln2)