（通过聊天）
OEIS条目A123321列出了由七个不同素数组成的数字序列。为简便起见，我们将其称为7DP号。前几个数字及其对应的除数如下：
510510 = 2 * 3 * 5 * 7 * 11 * 13 * 17
570570 = 2 * 3 * 5 * 7 * 11 * 13 * 19
690690 = 2 * 3 * 5 * 7 * 11 * 13 * 23
746130 = 2 * 3 * 5 * 7 * 11 * 17 * 19
这里的挑战是要从给定输入中找到绝对距离最接近的7DP号。
任何方便格式的单个正整数n。
再次以任何方便的格式最接近n的 7DP编号。如果将两个7DP数字并列为最接近的数字，则可以输出其中一个或两个。
5 -> 510510
860782 -> 870870
1425060 -> 1438710 (or 1411410, or both)
Answers:
f=lambda n,k=0:126^sum(1>>n%i<<7*(n/i%i<1)for i in range(2,n))and f(n+k,k%2*2+~k)or n该算法以O（scary）开头，递归并没有真正的帮助，但是只要n足够接近7DP数，它就可以很好地工作。
感谢@xnor打高尔夫球3个字节！
Python没有内置的素数或因式分解，但是我们可以通过其除数的数量和性质来识别7DP数字。
通过乘法原理，可以将整数的除数计算为其质数分解的增量指数的乘积。因此，σ 0（n）的（除数函数）是2 米每当Ñ是MDP数。
σ 0（N）= 128因此是一个必要条件，但它不是充分; 例如，σ 0（2 127）= 128，但2 127显然不是7DP数。然而，如果两个σ 0（N）= 128个没有完美的正方形分割Ñ均匀，再Ñ是7DP数。
对于输入n，算法在于检查整数n，n-1，n + 1，n-2，n + 2等，并返回第一个7DP数。
当f使用参数n调用，将发生以下情况：
代码
126^sum(1>>n%i<<7*(n/i%i<1)for i in range(2,n))如下测试n是否不是 7DP编号。
对于所有i使得1 <i <n的整数，1>>n%i<<7*(n/i%i<1)都会被求值。
如果n可被i整除，但不能被i 2整除，则1>>n%i得出1和(n/i%i<1)得出0，得出
1·2 7·0 = 1。
如果n可被i 2整除，1>>n%i并且(n/i%i<1)两者都得到1，则结果1·2 7·1 = 128。
如果n不能被i整除，则1>>n%i得出0，得出0·2 7·x = 0。
所得整数的和将是2 米 - 2如果Ñ是MDP号（其2 米除数，不含1和Ñ）和一个大于127如果Ñ具有完美的正方形因素。因此，当且仅当n为7DP数字时，总和为126。
对于7DP数字，总和为126，因此将其与126进行XOR 运算得出0，这是错误的。因此，执行lambda的一部分或部分，并且f返回n的当前值。
如果n不是7DP数字，则XOR将返回非零的真实值。因此，和执行lambda部分。
f(n+k,k%2*2+~k)以n的更新值递归调用f（下一个潜在的7DP编号）和k（新候选之差）。
如果k是偶数，非负整数，则k%2*2得出0并~k得出-（k +1）。这两个结果的总和是-（k + 1），这是一个奇数的负整数，为1比绝对值大ķ。
如果k是一个奇数，负整数，则k%2*2得出2并~k得出-（k + 1）。两个结果的总和为2-（k + 1）=-（k-1），这是一个偶数，非负整数，为1绝对值比k大单位。
这意味着k取值 0，-1、2，-3、4，⋯。
当累加到n 0（ Ñ），所得到的整数是
确保我们遇到的第一个7DP数是接近ñ 0越好。
:I=+.>0,.$pPdPl7
例：
?- run_from_atom(':I=+.>0,.$pPdPl7',1425060,Z).
Z = 1438710 .
难道这种语言并不总是很烂吗？我击败了果冻和MATL！
的测试用例5最长，在我的机器上大约需要10秒钟。
如果$p没有错误，这将是12个字节（我们不需要此>0,.部分）
Brachylog默认对所有整数算术使用约束逻辑编程。此外，内置的标记=可以在无限域上使用。
它连续地结合没有约束（即，在变量(-inf, inf)）作为这样的：0, 1, -1, 2, -2, 3, …。
因此，我们可以通过查找I统一的第一个数字(-inf, inf)（使用自动回溯）来获得最接近的7DP编号，该编号Input + I是7DP编号。
:I= Label variables in [Input, I]. I has no constraints and Input is known
+. Unify Output with Input + I
>0, Output > 0 (wouldn't be needed if $p failed for numbers less than 1)
.$pP Unify P with the list of prime factors of Output
dP Check that P with duplicates removed is still P
l7 Check that the length of P is 7
$p。从理论上讲，我不需要>0,，但是我的实现是有问题的：P
Input+1, Input-1, Input+2, Input-2, Input+3, ...用该方法找到的第一个7DP将是最接近的。
>0,.不需要）
Pµạ³,
×⁹ÆRœc7Ç€ṂṪ
理论上可行，但需要很多年才能完成。
这是一个实际可用于给定输入的版本，但理论上不能用于大输入：
Pµạ³,
50ÆRœc7Ç€ṂṪ
在这里尝试。这将生成最多50个素数，然后在该列表中找到素数的所有7个组合，然后是它们的所有乘积。最后，它只是简单地找到该列表中与给定参数最接近的元素。
当然，一旦我们的7DP包含的质数大于50，这将失败。理论版本会为输入n生成最大为256n的所有素数，但否则以相同的方式工作。
让p(x)表示之后的下一个素数x。最接近x的7DP产品的（极度宽松）上限是：
p(x) * p(p(x)) * p(p(p(x))) * ... * p(p(p(p(p(p(p(x)))))))
所以我们只需要检查[2…p（p（p（p（p（p（p（p（p（x（x）））））））））中的素数。贝特朗（Bertrand）的假设说p（x）≤2x，因此足以检查所有素数到128x。
×⁹ÆRœc7P€µạ³ỤḢị或×⁹ÆRœc7P€µạ³NMị（打印所有解决方案的数组）可节省几个字节。另外，×⁹可以更改+⁴以提高效率。
感谢Dennis提出的建议，该建议删除了4个字节，另一个建议又节省了1个字节！
t17*Zq7XN!pYk
从理论上讲，这是可行的，但以上输入6（在线编译器）的内存不足。
效率更高的版本使用21个字节，并在大约一秒钟的时间内计算所有测试用例：
t3e4/k16+_YqZq7XN!pYk
在线尝试！
以输入N = 860782为例。足以考虑素数M = 29，这是乘以2*3*5*7*11*13N的第一个素数。在此示例中，2*3*5*7*11*13*29 = 870870。下一个素数是31。涉及该质数或更高质数的任何产品都将至少为2*3*5*7*11*13*31 = 930930，因此可以保证不是解决方案，因为它870870超过N时会超过N。
M被计算为大于的第一个素数max(N/(2*3*5*7*11*13), 16)。该max功能用于确保至少17被拾取。为了节省几个字节，的代码替换2*3*5*7*11*13 = 30030的30000，和功能max加入。这些更改是有效的，因为它们提供了更大的价值。
t % Take input implicitly. Duplicate
3e4/k % Divide input by 30000 and round down (rounding here is only needed
% due to a bug in the "next prime" function)
16+ % Add 16
_Yq % Next prime
Zq % Prime numbers up to that value
7XN % Combinations of those primes taken 7 at a time. Gives a 2D array
% with each combination on a different row
!p % Product of each row
Yk % Output product that is closest to the input. Implicitly display
为了进一步减少字节数，可以删除除法；实际上，乘以17（感谢@Dennis）就足够了。这样可以确保包含下一个素数（根据Bertrand的假设），并且结果至少为17。从理论上讲，这是可行的，但对于大于的输入，内存会用完6。
在代码中，该部分
3e4/k % Divide input by 30000 and round down (rounding here is only needed
% due to a bug in the "next prime" function)
16+ % Add 16
_Yq % Next prime
被替换为
17* % Multiply by 17
!n=sort(map(prod,combinations(17n|>primes,7))-n,by=abs)[]+n这是 非常低效的，但实际上它适用于第一个测试用例，而理论上适用于其他测试用例。
以另外5个字节（总共64个字节）为代价，可以显着提高效率。
!n=sort(map(prod,combinations(n>>14+17|>primes,7))-n,by=abs)[]+n如@LuisMendo的答案中所述，我们必须考虑的最接近7DP数字的素数集很小。就足够了设置为包含7DP数量比所述输入更大Ñ，如果，如果它仅包含一个主要这将是真正的p≥17使得30300p = 2·3·5·7·11·13·P ≥n。
在包含至少一个质数的区间上证明间隔[X，1.5倍）含有至少一个质数，只要X≥8 。由于30030/16384≈1.83，这意味着每当n> 8·30300 = 242400时，必须有素数p in （n / 30030，n / 16384）。
最后，当n <510510时，p = 17显然足够，因此我们只需要考虑素数最大为n / 16384 + 17的素数。
以效率为代价，我们可以考虑将素数提高到17n。这在n = 1时有效，并且对于较大的n值，它远大于n / 16384 + 17。
17n|>primes并且n>>14+17|>primes（位移等于2 14 = 16384除）计算上一段中提到的素数范围。然后，combinations(...,7)计算该范围内七个不同质数的所有数组，并映射prod到这些数组上以计算其乘积，即从中选择答案的7DP数。
接下来，将每个7DP编号-n减去n个 prom，然后sort(...,by=abs)按其绝对值对这些差异进行排序。最后，我们选择与的第一个差异，[]并通过添加 ñ用+n。
L&{IPbq7lPby#.W!syMH,hhZa0teZ,
（5运行时间太长）
L&{IPbq7lPby#.W!syMH,hhZa0teZ,
L&{IPbq7lPb Defines a function y, whose argument is b:
& Return if both the following are true:
{IPb the prime factorization contains no duplicate; and:
q7lPb the number of prime factors is 7
y#.W!syMH,hhZa0teZ, The main programme. Input as Q.
,QQ Implicit arguments, yield [Q,Q].
.W While
!syMH both numbers do not satisfy y:
,hhZ increment the first number
teZ and decrement the second number
a0 while making it non-negative.
这是一种直接的方法，从开始n。
n如果素数的个数为7（PrimeNu@#==7），并且是7个素数素数的乘积，并且这些素数都不出现一次以上（SquareFreeQ@#&）。
g@n_:=(k=1;While[!(PrimeNu@#==7&&SquareFreeQ@#&)⌊z=n-⌊k/2](-1)^k⌋,k++];z)
我之前提交的文件（136字节）同时找到了上面的第一个7区别素数乘积n和（如果存在）下面的第一个7区别素数乘积n。然后简单地确定哪个更接近n。如果乘积是等距的，则两者都返回。
当前版本会检查n-1，n + 1，n-2，n + 2 ...直到它到达第一个7区别素数乘积。这个更有效的版本采用了Dennis采取的方法。
关键的进步在于⌊k/2](-1)^k⌋用于返回系列0、1，-1、2，-2 ...零用于检查其n本身是否为7个有区别的素数乘积。因此，使用Floor（⌊...⌋）代替Ceiling。
g[5]
g[860782]
g[1425060]
510510
870870
1438710
k直接更新为来交替散步。f(n+k,k%2*2+~k)k=0