您将获得以下函数：h1（f，* args）和h2（f，* args）

两者都是已经为您定义的方法（此处的星号表示可变数量的参数）

f是一个函数，* args是要传递给该函数的参数列表

h1返回一个布尔值：如果在* args上调用f时函数停止，则返回true；否则返回False（假定正在运行的计算机具有无限的时间和内存，并且您正在编写的语言的解释器/编译器）知道如何处理无限的时间和记忆）。

如果f（* args）曾经调用过h1或h2，则h1会引发异常

h2的行为与h1完全相同，只是如果f调用了h1，则h2不会引发异常

用尽可能少的字符编写一个无需输入且应输出的程序：

The Collatz Conjecture is {True/False}
Goldbach's Conjecture is {True/False}
The Twin Primes Conjecture is {True/False}

基于每个猜想的有效性。

以下是解释每个猜想的维基百科链接：

http://en.wikipedia.org/wiki/Collat​​z_conjecture

http://en.wikipedia.org/wiki/Goldbach%27s_conjecture

http://en.wikipedia.org/wiki/Twin_prime

您可以假设任何以您选择使用的语言编写的大整数库都将成功表示任意大整数。换句话说，我们假设任何能够表达的语言/库3**(3**10)也能够3**(3**(3**10))在足够强大的机器上表达。

显然，由于无法运行您的程序，请与代码一起说明其工作方式

J 207

(('The Collatz';'Goldbach''s';'The Twin Primes'),.<'Conjecture is'),.((>:^:((((-:`>:@*&3)^:(~:&1))^:_)&f)^:_ g 2)((+&2)^:(+./@1&p:@(-p:@_1&p:))^:_ f 4)(>:^:((4&p:)^:(2&~:&(-~4&p:))&f)^:_ g 3){'True':'False')

根据赏金，我选择使用f和g代替h1和h2；另外两个行（总共10个字符）可以切换：f=:h1，g=:h2。

和实际的逻辑：

科拉兹

>:^:((((-:`>:@*&3)^:(~:&1))^:_)&f)^:_ g 2

((-:`>:@*&3)^:(~:&1))^:_是它的肉；本质上是一个循环while (x != 1) x = collatz(x)。如果我们说那句话reduce：

>:^:(reduce&f)^:_ g 2

reduce&f是单调动词（请参阅末尾），其中reduce&f niff reduce(n)停顿才是真正的。其他loop-y位>:^:()^:_本质上是一个无限循环（>:为增量，^:可以用作条件循环和迭代器），该循环在遇到不会停止的Collat​​z约简时会中断。最后g调用，以查看无限循环是否终止。

哥德巴赫

(+&2)^:(+./@1&p:@(-p:@_1&p:))^:_ f 4

在大多数情况下，相同的逻辑在很大程度上是现在的核心计算+./@1&p:@(-p:@_1&p:)。-p:@_1&p:计算一个数字与所有小于该数字的质数之间的差，1&p:是一个isPrime函数，并且+./是逻辑或。因此，如果一个数与小于该数的任何质数之间的差也是质数，则满足哥德巴赫猜想，并且无限循环继续进行。再次，f在最终测试中使用该无限循环是否确实是无限的。

双素

>:^:((4&p:)^:(2&~:@(-~4&p:))&f)^:_ g 3

除以外，与上述相同(4&p:)^:(2&~:@(-~4&p:))。4&p:返回给定数字后的下一个最大素数。-~4&p:返回数字与后一个最大质数之间的差。2&~:是!= 2。因此，最里面的循环类似于while (nextPrimeAfter(p) - p != 2) p = nextPrimeAfter(p)。

笔记

可能有语法错误，因为我还没有与虚拟测试f和g呢。另外，我假设f并且g会采用某种形式，可以由左侧的动词和右侧的名词组成，但我不确定完全以任何方式遵守J语法。它们本质上是高阶函数，而且即使有这样合适的构造，我也太累了，无法找到合适的构造，如副词/连词/现在所拥有的。

我并没有真正使用正确的字符串连接，而是选择将单个字符串装箱。因此，输出（假设其他所有条件都是正确的）将是一个3列的表，左列是“ The Collat​​z”，等等，中间列是“ Conjecture is”，右列是“ True” /“ False” 。

我也很确定J默认情况下不会将整数转换为任意精度，并且至关重要的素数实用程序函数p:没有任意大的域。另一方面，鉴于J确实支持标准的任意精度数字类型，所以我不确定要使此代码达到标准需要花费多少精力。

哈斯克尔（242）

p n=and[rem n r>0|r<-[2..n-1]]
c 1=1
c n|odd n=c$3*n+1|0<1=c$div n 2
s!f=putStr(s++" Conjecture is ")>>print(not$h2$all(h1.f)[4..])
main=do"The Collatz"!c;"Goldbach's"! \n->or[p$n-r|r<-[2..n-2],p r];"The Twin Primes"! \n->or[p$r+2|r<-[n..],p r]

因为在Haskell中，变量不仅可以包含值，还可以包含计算（这称为惰性），所以我让自己h1, h2接受一个参数，然后返回天气，否则评估将停止。

有点不完整的代码：

h1 = undefined
h2 = undefined

prime n=and[rem n r>0|r<-[2..n-1]]
collatz 1=1
collatz n
    |odd n=collatz (3*n+1)
    |0<1  =collatz (div n 2)

s!f=do
    putStr (s++" Conjecture is ")
    print$not$h2$all(h1.f)[4..]

main=do
    "The Collatz"!c                                         --collatz
    "Goldbach's"! \n->or[prime (n-r)|r<-[2..n-2],prime r]   --goldbach
    "The Twin Primes"! \n->or[prime (r+2)|r<-[n..],prime r] --twin primes

一点解释：

当all应用于无限列表时，False由于懒惰（短路，对于其中所有非Haskell人士而言都是短路的），如果列表的元素之一是，它将停止。我们用它来计算collat​​z猜想和孪生素数猜想。

!将此技巧与打印一起打包。结果是True何时f终止所有数字4..。（这对于collat​​z猜想或双素数猜想都没有关系，因为我们已经知道它们对于如此小的数字是正确的）。

collat​​z猜想的代码是"The Collatz"!c。它显示“ Collat​​z Conjecture is”，结果是天气c在所有数字上终止4..。

哥德巴赫猜想的代码是"Goldbach's"! \n->or[p$n-r|r<-[2..n-2],p r]。 \n->or[p$n-r|r<-[2..],p r,r<n+1]是给定的函数n，如果它是两个素数之和，则返回True，否则无限循环。因此，如果每个4..戈德巴赫的猜想都停止了，那是真的。

双素数猜想的代码是"The Twin Primes"! \n->or[p$r+2|r<-[n..],p r]。 \n->or[p$r+2|r<-[n..],p r]是给定的函数n，如果有多个大于的素数n，则返回True，否则将无限期循环。因此，如果每个4..双素素猜想都停止，那是真的。

Python（965个字符）

因为我的问题是没有爱。我正在用Python发布我的（非代码查询）解决方案：

def numCollatzSteps(n):
    numSteps=0
    while n>1:
        if n%2==0:
            n//=2
        else:
            n=3*n+1
        numSteps+=1
    return numSteps

def findNonHaltingN():
    for n in count(1):
        if not h1(numCollatzSteps,n):
            return n

print "The Collatz Conjecture is "+str(not h2(findNonHaltingN))

def isPrime(n):
    for i in range(2,n):
        if n%i==0:
            return False
    else:
        return True

def isSumOf2Primes(n):
    for i in range(2,n-2):
        if isPrime(i) and isPrime(n-i):
            return True
    else:
        return False

def findNonSum():
    for i in count(4,2):
        if not isSumOf2Primes(i):
            return i

print "Goldbach's Conjecture is "+str(not h1(findNonSum))

def isSmallTwinPrime(n):
    return isPrime(n) and isPrime(n+2)

def nextSmallTwinPrime(n):
    for i in count(n):
        if isSmallTwinPrime(i):
            return i

def largestTwinPrimes():
    for n in count(2):
        if not h1(nextSmallTwinPrime,n):
            return n-1,n+1

print "The Twin Primes Conjecture is "+str(not h2(largestTwinPrimes))

这很简单。

numCollat​​zSteps（n）表示特定n的Collat​​z序列需要执行多少步。如果所说的Collat​​z序列不终止，它将无限地运行。

findNonHaltingN（）向上计数，以检查numCollat​​zSteps是否每隔n个终止。当且仅当存在一个numCollat​​zSteps不终止的n时，findNonHaltingN终止。

因此，我们可以通过检查findNonHaltingN（）不停止来检查Collat​​z猜想是否为真

isPrime（n）通过查看从1到n-1的正整数是否除以该数来检查数字是否为质数

isSumOf2Primes（n）迭代2到n-2之间的所有正整数，并检查至少一个为素数及其补码

findNonSum（）从4开始向上计数偶数，直到达到第一个不是2个质数之和的数字，然后将其返回。如果没有这样的数字，它将无限地继续。

通过查看findNonSum不会停止，我们可以检查Goldbach的猜想是否成立。

当且仅当n和n + 2均为素数时，isSmallTwinPrime（n）返回true

nextSmallTwinPrime（n）返回isSmallTwinPrime为true的下一个数字> = n

maximumTwinPrimes（）从2开始向上计数，以检查nextSmallTwinPrime对所有n都停止。如果nextSmallTwinPrime从未停止过大约n个，则得出最大的孪生素数是n-1和n + 1，我们就停在那里

然后我们可以通过检查maximumTwinPrimes永不停止来检查双素数猜想的有效性。

APL（234）

这显然未经测试，但逻辑似乎很合理。包括所有打印命令，输出为104字符，实际逻辑为130。

Z←' Conjecture is '∘,¨'True' 'False'
⎕←'The Collatz',Z[1+{~{1=⍵:⍬⋄2|⍵:∇1+3×⍵⋄∇⍵÷2}h1⍵:⍬⋄∇⍵+1}h2 1]
⎕←'Goldbach''s',Z[1+{~⍵∊∘.+⍨N/⍨~N∊∘.×⍨N←1+⍳⍵:⍬⋄∇⍵+2}h1 2]
⎕←'The Twin Primes',Z[1+{~(T←{∧/{2=+/(⌈=⌊)⍵÷⍳⍵}¨N←⍵+1:N⋄∇N})h1⍵:⍬⋄∇T⍵}h2 4 2]

取消高尔夫：

⍝ Environment assumptions: ⎕IO=1 ⎕ML=1
⍝ I've also assumed h1 and h2 are APL operators
⍝ i.e. x F y = f(x,y); x (F h1) y = h1(F,x,y)

⍝ 'Conjecture is True', 'Conjecture is False'
Z←' Conjecture is '∘,¨'True' 'False'

⍝⍝⍝ Collatz Conjecture
⍝ halts iff 1 is reached from given ⍵
collatzLoop←{
   1=⍵:⍬       ⍝ ⍵=1: halt
   2|⍵:∇1+3×⍵  ⍝ ⍵ uneven: loop with new val
   ∇⍵÷2        ⍝ ⍵ even: loop with new val
}

⍝ halts iff 1 is *not* reached from a value ≥ ⍵ (collatz false)
collatzHalt←{~collatzLoop h1 ⍵:⍬⋄∇⍵+1}

⍝ does it halt?
⎕←'The Collatz',Z[1+ collatzHalt h2 1]


⍝⍝⍝ Goldbach's Conjecture

⍝ Can ⍵ be expressed as a sum of two primes?
sumprimes←{
    N←1+⍳⍵         ⍝ N=[2..⍵+1]
    P←(~N∊N∘.×N)/N ⍝ P=primes up to ⍵+1×⍵+1
    ⍵∊P∘.+P        ⍝ can two P be summed to ⍵?
}

⍝ halts iff Goldbach is false
goldbachHalt←{
    ~sumprimes ⍵:⍬ ⍝ not a sum of primes: halt
    ∇⍵+2           ⍝ try next even number
}

⍝ does it halt?
⎕←'Goldbach''s',Z[1+ goldbachHalt h1 2]

⍝⍝⍝ Twin Primes

⍝ is it a prime?
isPrime←{
   2=+/(⌊=⌈)⍵÷⍳⍵    ⍝ ⍵ is a prime if ⍵ is divisible by exactly two
                   ⍝ numbers in [1..⍵] (i.e. 1 and ⍵)
}

⍝ find next twin
nextTwin←{
   N←⍵+1            ⍝ next possible twin
   ∧/ isPrime¨ N:N  ⍝ return it if twin
   ∇N               ⍝ not a twin, search on
}       

⍝ halts iff no next twin for ⍵
twinPrimeHalt←{
   ~nextTwin h1 ⍵: ⍬  ⍝ if no next twin for ⍵, halt
   ∇nextTwin ⍵        ⍝ otherwise try next twin
}

⍝ does it halt?
⎕←'The Twin Primes',Z[1+ twinPrimeHalt h2 4 2]