python 代码

# # 定义常量
# N = 10**6 + 10

# # 存储素数的列表
# primes = []
# # 标记数组
# st = [False] * N
# # 素数的数量
# cnt = 0

# # 生成素数的函数
# def get_primes(n):
#     global cnt
#     st = [False] * N
#     cnt = 0
#     for i in range(2, n + 1):
#         if not st[i]:
#             primes.append(i)
#             cnt += 1
#         j = 0
#         while j < cnt and primes[j] * i <= n:
#             st[primes[j] * i] = True
#             if i % primes[j] == 0:
#                 break
#             j += 1

# # 主程序
# while True:
#     try:
#         # 读取输入的左右边界
#         l, r = map(int, input().split())
#         # 生成小于等于 50000 的素数
#         get_primes(50000)

#         # 标记 [l, r] 区间内的合数
#         st = [False] * (r - l + 1)
#         for p in primes:
#             start = max(2 * p, ((l + p - 1) // p) * p)
#             for j in range(start, r + 1, p):
#                 st[j - l] = True

#         # 找出 [l, r] 区间内的素数
#         prime_in_range = []
#         for i in range(r - l + 1):
#             if not st[i] and i + l > 1:
#                 prime_in_range.append(i + l)

#         # 如果素数数量小于 2
#         if len(prime_in_range) < 2:
#             print("There are no adjacent primes.")
#         else:
#             # 计算最小和最大间隔
#             minp = 0
#             maxp = 0
#             for i in range(len(prime_in_range) - 1):
#                 d = prime_in_range[i + 1] - prime_in_range[i]
#                 if d < prime_in_range[minp + 1] - prime_in_range[minp]:
#                     minp = i
#                 if d > prime_in_range[maxp + 1] - prime_in_range[maxp]:
#                     maxp = i
#             print(f"{prime_in_range[minp]},{prime_in_range[minp + 1]} are closest, {prime_in_range[maxp]},{prime_in_range[maxp + 1]} are most distant.")
#     except:
#         break
def get_primes(n):
    minp = [0] * (n + 1)
    st = [False] * (n + 1)
    cnt = 0
    primes = []
    for i in range(2, n + 1):
        if st[i] == False:
            primes.append(i)
            cnt = cnt + 1
            minp[i] = i
        j = 0
        while j < cnt and primes[j] * i <= n:
            t = primes[j] * i
            st[t] = True
            minp[t] = primes[j]
            if i % primes[j] == 0:
                break
            j = j + 1
    return primes,minp,cnt
primes,minp,cnt = get_primes(50000)

while True:
    try:
        l,u = map(int,input().split())
        new_st = [False] * ((u - l) + 1)
        for p in primes:
            start = max(2 * p,((l + p - 1) // p) * p)
            for j in range(start,u + 1,p):
                new_st[j - l] = True
        ans = []
        for i in range(u - l + 1):
            if new_st[i] == False and i + l > 1:
                ans.append(i + l)
        if len(ans) < 2:
            print("There are no adjacent primes.")
        else:
            mi = 0
            ma = 0
            for i in range(len(ans) - 1):
                d = ans[i + 1] - ans[i]
                if d < ans[mi + 1] - ans[mi]:
                    mi = i
                if d > ans[ma + 1] - ans[ma]:
                    ma = i
            print(f"{ans[mi]},{ans[mi + 1]} are closest, {ans[ma]},{ans[ma + 1]} are most distant.")

    except:
        break