次の関数が与えられます：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文字の2行を追加すれば、切り替えに十分です：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 n場合に真である、単項動詞（終わりを参照）であることを意味します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関数であり、+./論理和です。したがって、数とその数より小さい素数との差も素数である場合、Goldbach予想が満たされ、無限ループが続きます。繰り返しますが、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」など、中央の列は「推測」、右の列は「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です。「The Collat​​z Conjecture is」と出力され、その結果である天気cはすべての数字で終了します4..。

goldbach予想のコードは"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]は、n2つの素数の合計である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ごとに終了することを確認しながら上向きにカウントします。findNonHaltingNは、numCollat​​zStepsが終了しないnが存在する場合にのみ終了します。

したがって、findNonHaltingN（）が停止しないことを確認することにより、Collat​​z予想が真であるかどうかを確認できます。

isPrime（n）は、1からn-1までの正の整数がそれを除算しないことを確認することにより、数値が素数であるかどうかをチェックします

isSumOf2Primes（n）は、2からn-2までのすべての正の整数を反復処理し、少なくとも1つがその補数とともに素数であることを確認します

findNonSum（）は、2の素数の合計ではない最初の数に達するまで、4から偶数をカウントし、それを返します。そのような番号が存在しない場合、無限に継続します。

findNonSumが停止しないことを確認することで、Goldbachの推測が正しいかどうかを確認できます。

isSmallTwinPrime（n）は、nとn + 2が両方とも素数である場合にのみtrueを返します

nextSmallTwinPrime（n）は、isSmallTwinPrimeがtrueである次の数値> = nを返します

最大TwinPrimes（）は、nextSmallTwinPrimeがすべてのnについて停止することを確認する2からカウントアップします。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]