描述

本题要求实现一个计算整数因子和的简单函数，并利用其实现另一个函数，输出最小的N(1 <= N <=8)个完数。所谓完数就是该数恰好等于除自身外的因子之和。例如：6=1+2+3，其中1、2、3为6的因子。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬
输入格式
一个正整数N，如：1‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬

输出格式

如：6=1+2+3

找出一个数的所有因子，根据这些因子的和是否与该数相等，判定该数是否是完数

  1. def factor(num):                      # 寻找 num 的所有因子
  2.     ls = []
  3.     for i in range(1, num):
  4.         if num % i == 0:
  5.             ls.append(i)              # 将num的所有非本身因子加入列表
  6.     if sum(ls) == num:                # 如果num是完数，返回列表，否则返回False
  7.         return ls                     # 返回包含完数所有因子的列表
  8.     else:
  9.         return False

找到前n个完数

  1. def oupput(n):                       # 按格式输出找到的完数
  2.     count,i = 1,1                    # 计数器置1
  3.     while count <= n:                # 只寻找前n个完数
  4.         if factor(i):                # 如果i 是完数，按格式输出
  5.             print('{}={}'.format(i, '+'.join([str(x) for x in factor(i)])))
  6.             count = count + 1
  7.         i = i + 1

完整参考程序为：

  1. def factor(num):                      # 寻找 num 的所有因子
  2.     ls = []
  3.     for i in range(1, num):
  4.         if num % i == 0:
  5.             ls.append(i)              # 将num的所有非本身因子加入列表
  6.     if sum(ls) == num:                # 如果num是完数，返回列表，否则返回False
  7.         return ls
  8.     else:
  9.         return False
  11. def oupput(n):                       # 按格式输出找到的完数
  12.     count,i = 1,1                    # 计数器置1
  13.     while count <= n:                # 只寻找前n个完数
  14.         if factor(i):                # 如果i 是完数，按格式输出
  15.             print('{}={}'.format(i, '+'.join([str(x) for x in factor(i)])))
  16.             count = count + 1
  17.         i = i + 1
  19. if __name__ == '__main__':
  20.     n = int(input())                # 此处要求输入为正整数
  21.     oupput(n)                       # 调用输出函数

这个题目的计算量比较大，如果想找到更多的完数，需要使用一些算法，例如数学方法 ：
6=1+2+3 (22-1)+(22-1)1=2(22-1)
28=1+2+4+7+14 (23-1)+(23-1)*(22-1)=22*(23-1)
496=1+2+4+8+16+31+62+124+248 (25-1)+(25-1)(24-1)=(24)(25-1)
8128=1+2+4+8+16+32+64+127+254+508+1016+2032+4064 (27-1)+(27-1)*(26-1)=(26)*(27-1)
33550336= 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8191, 16382, 32764, 65528, 131056, 262112, 524224, 1048448, 2096896, 4193792, 8387584, 16775168]
如果 m 是素数，且 2 m - 1 也是素数，那么2 (m - 1) (2 * m - 1) 是一个完数。
判断素数的函数 ：

  1. def isPrime(n):                          # 判断素数的函数
  2.     if n < 2:
  3.         return False                       # 0和1不是素数
  4.     for i in range(2, int(n**0.5)+1):
  5.         if n % i == 0:
  6.             return False
  7.     else:
  8.         return True

判断完全数的函数：

  1. def isPerfect(m):                           # 判断完数的函数
  2.     if isPrime(m) and isPrime(2 * *m - 1):  # 如果 m 和 2 ** m - 1 都是素数
  3.         s = 2 ** (m - 1) * (2 ** m - 1)     # 2 ** (m - 1) * (2 ** m - 1) 是一个完数
  4.         ls.append(s)                        # 完数加入到列表中
  5.         i=0
  6.         while s % 2 ==0:                    # 对完数进行分解因数
  7.             s=s // 2
  8.             factor.append(s)                # s // 2 和 2 ** i 次方同时是因子
  9.             factor.append(2 ** i)
  10.             # 496=1+2+4+8+16+  31   +62+124+248
  11.             i = i + 1
  12.         if len(factor) % 2 == 0:            # 加入最后一个因子 2 ** i
  13.             factor.append(2 ** i)
  14.         return s
  15.     else:
  16.         return False

完整参考代码，以下代码可以完成前9个完数的输出：

  1. def isPrime(n):          #判断素数的函数
  2.     if n < 2:
  3.         return False     #0和1不是素数
  4.     for i in range(2, int(n**0.5)+1):
  5.         if n % i == 0:
  6.             return False
  7.     else:
  8.         return True
  9. def isPerfect(m):                      #判断完数的函数
  10.     if isPrime(m) and isPrime(2**m-1):
  11.         s = 2**(m-1)*(2**m-1)
  12.         ls.append(s)
  13.         i=0
  14.         while s%2 ==0:
  15.             s=s//2
  16.             factor.append(s)
  17.             factor.append(2**i)
  18.             i = i+1
  19.         if len(factor)%2==0:
  20.             factor.append(2 ** i)
  21.         return s
  22.     else:
  23.         return False
  26. if __name__ == '__main__':
  27.     n = int(input())                # 此处要求输入为正整数
  28.     ls = []
  29.     count, num = 0, 1
  30.     while count < n:
  31.         factor = []
  32.         if isPerfect(num):
  33.             factor.sort()
  34.             print('{}=1'.format(ls[count]), end='')
  35.             for j in factor[1:]:
  36.                 print("+{}".format(j), end='')
  37.             count = count + 1
  38.             print()
  39.         num = num + 1

还有一种更高效的方法，可以完成前14个完数的输出：

  1. # 公管大数据1901班康佳丽
  2. n = int(input())
  3. def isPrime(N):
  4.     if N < 4: return N > 1
  5.     if ((N & 1) == 0): return False
  6.     i = 3
  7.     while i * i <= N :
  8.         if (N % i) == 0 :
  9.             return False
  10.         i += 2
  11.     return True
  12. def primality(N, M):
  13.     if N == 2 :
  14.         return True
  15.     s = 4
  16.     for i in range(0, N - 2) :
  17.         s = (s * s - 2) % M
  18.     return s == 0
  20. def findPerfectNumber() :
  21.     count = 0
  22.     ls=[]
  23.     for i in range(2, 5000):
  24.         M = (1 << i) - 1
  25.         t = M << (i-1)
  26.         # 当p为素数且梅森数2^p-1为素数时2^(p-1)*(2^p-1)为完全数
  27.         if isPrime(i) and primality(i,M) :
  28.             count += 1
  29.             ls.append(t)
  30.         if count>n-1:
  31.             return(ls)
  32. Lis=findPerfectNumber()    # 得到包含前n位完数的列表
  34. def Yinzi(s):              # 获取每个完数的因子
  35.     i=0
  36.     while s%2 ==0:
  37.         s=s//2
  38.         factor.append(s)
  39.         factor.append(2**i)
  40.         i = i+1
  41.     if len(factor)%2==0:
  42.         factor.append(2 ** i)
  43.     return factor
  45. count = 0
  46. ls = []
  47. for i in Lis:
  48.     factor=[]
  49.     factor = Yinzi(i)
  50.     factor.sort()
  51.     print('{}=1'.format(Lis[count]), end='')
  52.     for j in factor[1:]:
  53.         print("+{}".format(j), end='')
  54.     count = count + 1
  55.     print()