描述

数学领域著名的“哥德巴赫猜想”的大致意思是：任何一个大于2的偶数总能表示为两个素数之和。比如：24=5+19，其中5和19都是素数。本实验的任务是设计一个程序，验证20亿以内的偶数都可以分解成两个素数之和。输入一个大于2的正整数，当输入为偶数时，在一行中按照格式“N = p + q”输出N的素数分解，其中p 、 q均为素数且p ≤ q。因为这样的分解可能不唯一（例如24还可以分解为7+17），要求必须输出所有解中p最小的解。当输入为奇数时，输出’Data error!’ 。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬

输入格式

输入一个不小于2的正整数‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬

输出格式

当输入为偶数时，按照格式“N = p + q”输出N的素数分解；当输入为奇数时，输出’Data error!’ 。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬

输入输出示例

输入 输出
示例 1 36 N = 5 + 31

解析：
这个问题最重要的是判断素数，可以将其定义为一个函数。再分别判断i,j是否是素数和二者的各是等于N。
一个break只能退出一重循环，当循环有两重以上时，用一个break无法退出所有循环。此时可以用做标志的方法，在内层循环中改变标志的值。外层循环中根据标志的值是否被改变决定是继续循环还是退出循环。 

  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
  10. N = int(input())        # 接收用户输入并转成整数
  11. flag = False            # 设置一个未找到解的标记，找到解后将其值改为True
  12. if N % 2 == 0:          # 当N为偶数时进行以下处理
  13.     for i in range(N):
  14.         for j in range(N):
  15.             if isPrime(i) and isPrime(j)  and i+j==N: # i,j都是素数且和为N
  16.                 print("N = {} + {}".format(i,N-i))
  17.                 flag = True
  18.                 break
  19.         if flag:
  20.             break
  21. else:
  22.     print('Data error!')

实际上 j 不需要遍历，可由N-i计算得到，可以减少一重循环，当循环只有一重时，可以用一个break直接退出：

  2. def isPrime(n):          #判断素数的函数
  3.     if n < 2:
  4.         return False     #0和1不是素数
  5.     for i in range(2, n):
  6.         if n % i == 0:
  7.             return False
  8.     else:
  9.         return True
  10. N = int(input())        #接收用户输入并转成整数
  11. if N % 2 == 0:
  12.     for i in range(N):
  13.         if isPrime(i) and isPrime(N - i) :
  14.             print("N = {} + {}".format(i,N-i))
  15.             break
  16. else:
  17.     print('Data error!')