这是我想到的一个代码高尔夫球挑战。挑战在于编写尽可能短的代码，以使代码是否终止是一个悬而未决的问题。我的意思的示例可能是下面的一段python代码，从anwser改编成这个 cs stackexchange 问题。

def is_perfect(n):
    return sum(i for i in range(1, n) if n % i == 0) == n

n = 3
while not is_perfect(n):
    n = n + 2

数学家们猜测没有奇数完美的数字，但是它从未得到证明，因此没有人知道这段代码是否会终止。您能否提出较短的其他代码段（也许依赖于其他未解决的问题，例如Collat​​z猜想或孪生素数猜想），但是它们是否终止并不知道？

编辑：有些人提出了一个很好的附加规则-问题的解决方案应该是确定性的。尽管如果您可以使用不确定性找到更短的解决方案，可能会更加有趣。在这种情况下，规则是找到一个终止概率未知的代码段。

果冻，7 个字节

!‘Ʋµ4#

在线尝试！

背景

一旦找到Brocard问题的第四个解决方案，即解决方案n！+1 =m²，在正整数上具有（n，m）≠（4，5），（5，11），（7，71）。该实现不使用浮点算法，因此只有在找到第四个解或n时，它才会终止。不能再在内存中表示。

Brocard的问题最早是由@xnor 在此答案中使用的。

这个怎么运作

!‘Ʋµ4#  Main link. No arguments. Implicit argument: 0

    µ4#  Convert the links to the left into a monadic chain and call it with
         arguments k = 0, 1, 2, ... until 4 of them return 1.
!        Factorial; yield k!.
 ‘       Increment; yield k! + 1.
  Ʋ     Squareness; return 1 if k! + 1 is a perfect square, 0 if not.

果冻，11 9 字节

ÆẸ⁺‘ÆPµ6#

一旦找到第六个费马素数，它将终止。

在线尝试！

这个怎么运作

ÆẸ⁺‘ÆPµ6#  Main link. No arguments. Implicit argument: 0

      µ6#  Convert the links to the left into a monadic chain and call it with
           arguments k = 0, 1, 2, ... until 6 of them return 1.
ÆẸ         Convert [k] to the integer with that prime exponent factorization, i.e.,
           into 2 ** k.
  ⁺        Repeat.
   ‘       Increment.
           We've now calculated 2 ** 2 ** k + 1.
    ÆP     Test the result for primality.

Pyth，10个字节

fP_h^2^2T5

使用所有费马数 2^(2^n)+1都为的复合猜想n>4。

f        5   Find the first number T>=5 for which
   h^2^2T    2^(2^T)+1
 P_          is prime                   

Python，36个字节

k=n=1
while(n+1)**.5%1+7/k:k+=1;n*=k

使用Brocard的问题：

n！+1是任何n≥8的完美平方吗？

计算连续的阶乘，并检查它们是否为正方形并具有k>7。感谢Dennis提供2个字节！

假设Python继续对任意大数具有准确的算法。在实际实现中，它终止。

Perl，50 38 36 34 33字节

$_=196;$_+=$%while($%=reverse)-$_

说明：196是一个可能的Lychrel数 -该数字不会通过重复添加反向来形成回文。循环继续进行，直到$ n等于其倒数为止，对于初始值196尚不知道。

25 + 52 = 77

这是无效的。

96 + 69 = 165
165 + 561 = 726
726 + 627 = 1353
1353 + 3531 = 4884

因此此序列中的数字均无效。

编辑：通过使用直到循环，而不是for循环（某种程度上）打败它。另外，我的字节数少于我的预期（将来我可能会更仔细地查看字节数）。

编辑：替换$n用$_节省2个字节的隐含参数reverse。我认为这与该实现将要实现的目标一样。

编辑：我错了。而不是使用until($%=reverse)==$_我可以去，而不同的是非零（即真）while($%=reverse)-$_。

MATL，11个字节

`@QEtZq&+=z

如果哥德巴赫猜想是假的，则终止。也就是说，如果程序发现一个大于2不能表示为两个质数之和的偶数，则程序将停止。

`        % Do...while
  @      %   Push iteration index k. Gives 1, 2, 3, ...
  QE     %   Add 1 and multiply by 2. Gives 4, 6, 8, ...
  tZq    %   Duplicate. Push all primes up to current k
  &+     %   Matrix with all pairwise additions of those primes
  =z     %   Number of entries of that matrix that equal k. This is used as loop
         %   condition. That is, the loop continues if this number is nonzero
         % Implicit end

05AB1E，8个字节

找到第6个Fermat素数时终止。

5µNoo>p½

说明

5µ          # loop over increasing N (starting at 1) until counter reaches 5
  Noo       # 2^2^N
     >      # + 1
      p½    # if prime, increase counter

Python，30 28字节

n=2
while 2**~-n%n**3-1:n+=1

当且仅当存在大于1的整数n使得2 ^（n-1）-1被n ^ 3整除时，该程序才会暂停。据我所知，尚不存在具有该属性的任何数字（如果满足该属性的数字是质数，则称为维夫里奇素数，以3为底数为2，并且是否存在这样的素数是开放的）。

Haskell，47个字节

[n|n<-[1..],2*n==sum[d|d<-[2..n],n`mod`d<1]]!!0

搜索第一个拟完美数，该n数是除数之和为的数字2*n+1。我没有添加1，而是从除数列表中排除了1。

脑高射炮，212个 208 204字节

该程序使用由MegaTom编写的乘法算法和由1000000000编写的非平方检查器

在线试用

(((()()()()){})){{}((({}()))<{(({})[()])}{}>[()]){({}<({}<>)({<({}[()])><>({})<>}{}<><{}>)>[()])}{}(({}())){(({}[()]<>)<>)(({({})({}[()])}{}[({})]<>)){{}{}({}<>)(<([()])>)}{}({}()){(((<{}{}<>{}>)))}{}}{}}

该程序从8开始，测试每个数字以查看n！+1是否为平方数。找到一个就退出。这就是Brocard问题，在数学上是一个开放性问题。

Brachylog（v2），采用Brachylog编码的3个字节

⟦cṗ

在线尝试！（由于明显的原因，超时将不做任何可见的操作）

完整程序；如果运行时没有输入，则搜索第一个Smarandache prime，true.并在找到时输出输出。是否存在任何Smarandache素数是一个悬而未决的问题。（请注意，尽管Brachylog的素数测试算法在理论上适用于任意大的数，但往往会对其运行缓慢；因此，如果您有兴趣自行寻找Smarandache素数，我建议使用其他语言。）

说明

⟦cṗ
⟦     Form an increasing range from 0 to {the smallest number with no assertion failure} 
 c    Concatenate all the numbers that make up that range, in decimal
  ṗ   Assert that the result is prime

每当您尝试将数字视为列表时，Brachylog都会对数字的十进制数字进行操作，因此“ range”后接“ concatenate”是生成Smarandache数字序列的一种非常简洁的方法（然后我们按素数对其进行过滤； Brachylog的默认的完整程序行为将强制生成的生成器的第一个元素）。该范围有一个前导零，但幸运的是，有了这种流动模式，Brachylog删除了零而不是失败了。

这是一个示例，该示例查找等于6（mod 11）的第一个Smarandache编号，作为一个类似程序的演示，该程序在60秒内终止而不是具有未知的停止状态：

⟦c{-₆~×₁₁&}

在线尝试！

这将true.作为完整程序打印，但是我使用了Z命令行参数来实际打印有问题的数字，从而更好地证明了这种通用方法有效。

Python 2，88个字节

p=lambda n:all(n%x for x in range(2,n))
s=lambda n:0if p((10223*2**n)+1)else s(n+1)
s(0)

如果10223是Sierpiński号码，则此代码将终止。截至2013年12月，目前最小的候选数可能是或可能不是Sierpiński号码，即10223。

Sierpiński编号是一个数字k，其中所有形式的数字(k * 2^n) + 1都是复合的。

Pyth，16个字节

f!}1.u@,/G2h*3GG

返回Collat​​z猜想不成立的第一个值。由于尚不确定所有数字是否成立，因此尚不清楚该代码是否会终止。

实际上，16个字节

1`;;pY)▒@D÷íu*`╓

在线尝试！

此代码终止当且仅当有一些合数n，使得totient(n)分裂n-1（莱默的欧拉问题）。

说明：

1`;;pY)▒@D÷íu*`╓
1`            `╓  first integer, starting with 0, where the following function leaves a truthy value on top of the stack:
    pY       *      composite (not prime) and
   ;  )▒            totient(n)
  ;     @D֒u       is in the list of divisors of n-1

果冻，9 8 字节

-1个字节感谢@Dennis！（使用指数运算而不是乘法运算可避免Æṣ(0)）

*ḂÆṣ=µ2#

将返回零和最小的奇数（如果存在）的列表。

怎么样？

*ḂÆṣ=µ2# - Main link: no arguments
     µ   - monadic chain separation
      2# - count up from implicit `n=0` and return the first 2 truthy results of
 Ḃ       -     mod 2        -> n%2
*        -     exponentiate -> n**(n%2)  (1 when n is even, n when n is odd)
  Æṣ     -     sum of proper divisors of n**(n%2)
    =    -     equals n?    -> 1 if n is zero or both perfect and odd, else 0

Haskell，46个字节

[n|m<-[1..],n<-[1..m],product[1..n]+1==m^2]!!3

如果找到brocard问题的第四个解决方案，则终止。

Python，92个字节

这并没有赢得任何代码高尔夫比赛的胜利，并且它需要无限的内存和递归深度，但这是一个几乎完美的机会，可以插入两年前我在数学stackexchange上问到的一个有趣的问题，即总和不大于8的斐波那契数两个正立方体。有趣的是，它最初是一个标准的高尔夫挑战赛主意，所以我想我已经走了一大圈。

def f(i,j):
 r=range(i)
 for a in r:
  for b in r:
   if a**3+b**3==i:1/0
 f(j,i+j)
f(13,21)

Python 2，123 98 92字节

p=lambda n,k=2:n<=k or n%k*p(n,k+1)
g=lambda n:[p(b)*p(n-b)for b in range(n)]and g(n+2)
g(4)

如果戈德巴赫猜想对所有偶数都不成立（即，如果所有偶数都可以表示为两个素数之和），则该代码将终止。目前已经测试了最大4 * 10 ^ 18的数字。

非常感谢@ Pietu1998大大缩短了我的代码！

编辑：感谢@JonathanAllan从我的代码中节省了6个字节！

的JavaScript（ES6），104个 101字节

for(n=[6,9,p=1];!p;n=n.map((x,i)=>(q=n[n.length+~i],p|=x^q,c=q+x+c/10|0)%10).concat(c/10|0||[]))c=p=0

使用与Perl答案相同的方法：将n设置为196，然后将n反向添加到10的底数中，直到它成为以10为底的回文。如果JS支持任意精度数，则该长度会更短，但是很好。

Python，80个字节

如果Collat​​z猜想被证明是假的，则终止。看到这个问题。

n=2
while 1:
 L=[];x=n
 while~-n:1/(n not in L);L+=[n];n=(n/2,n*3+1)[n%2]
 n=x+1

Python 2，64字节

Lychrel数是一个自然数，它不能通过反复反转其数字并将其相加得到的迭代过程来形成回文。

没有利克瑞尔号码已被证明在基地十到存在。196是最小的以10为底的Lychrel数候选者。研究表明，如果存在回文（使196 不是 Lychrel数），则该数将至少有十亿（10 ^ 9）个数字，因为人们已经运行了那么长时间的算法。

n=196
while 1:
    x=str(n);r=x[::-1]
    if x!=r:n=n+int(r)
    else:1/0

果冻，7个字节

*+3Ẓµ4#

在线尝试！（打印两个元素，而不是4，以便您实际上可以看到它停止了）

$n$$n^n+3$

说明

*+3Ẓµ4#
     4#  Find the first four numbers with the following property:
    µ      (bracketing/grouping: place everything to the left inside the loop)
*          {The number} to the power of {itself}
 +3        plus 3
   Ẓ       is prime

R，30字节，可否确定

while(any(sample(2,654,T)>1))1

R的默认随机数生成器在653个连续维中具有均等分布，但在654个维中未知。因此，可能有也可能没有伪随机数序列，该伪随机数连续654次从给定向量中对最低元素进行采样（此处为vector 1:2）。

由于R的RNG是周期性的（尽管周期很长），因此我认为这是确定性的，因为它最终将循环循环至起点。当然，您的意见可能会有所不同。

Python 3，101个字节

我知道它比很多其他的更长，但是我花了很多时间看我能打多短。

这试图反驳欧拉猜想的k=6（不存在正整数解的丢番图方程A^6+B^6+C^6+D^6+E^6==F^6）内，如果没有反被发现。

R=[1]
while 1:R+=[R[-1]+1];eval(("[1/("+"+%s**6"*5+"!=%%s**6)%s]"%("for %s in R "*6))%(*"ABCDEF"*2,))

在Python 2（104位元组）中：

R=[1]
while 1:R+=[R[-1]+1];eval(("[1/("+"+%s**6"*5+"!=%%s**6)%s]"%("for %s in R "*6))%tuple("ABCDEF"*2))

少打高尔夫球：

x=2
while 1:
    R=range(1,x)
    [1/(A**6+B**6+C**6+D**6+E**6!=F**6)for F in R for E in R for D in R for C in R for B in R for A in R]
    x+=1

没有评估的数学版本：

R=range
x=2
while 1:
    for i in R(x**6):1/(sum(map(lambda x:x**6,[1+(i%x**-~j/x**j)for j in R(6)]))-i%x-1)
    x+=1

替代参考：欧拉的幂和猜想-MathWorld

Python，68个字节

n=2
while"".join(str((i+2)**n)[0]for i in range(8))!="23456789":n+=1

在线尝试

尝试回答Gelfand的问题之一。

2. 是否会在n> 1时出现“ 23456789”行？对于n <= 10 ^ 5，无。...

Clojure，154个字节

(loop[x 82001](if(= 0(reduce +(map{true 1 false 0}(for[y(range 3 6)](true?(for[z(str(range 2 y))](.indexOf z(Integer/toString x y))))))))x(recur(inc x))))

检查是否有一个大于82,000的数字，从2一直到以5为基数，都只包含0和1。换句话说，它检查此序列中是否还有另一个数字。

在这特殊的群体，只有3个数字：0，1和82,000。没有更多的符合该规则的数字小于3*10^19723。

Pyt，14个字节

27*²0`ŕĐ₫+Đ₽¬ł

mbomb007的答案端口。