Bạn được cung cấp các hàm: h1 (f, * args) và h2 (f, * args)

Cả hai đều là các phương thức đã được xác định cho bạn (ở đây dấu hoa thị cho biết số lượng đối số thay đổi)

f là một hàm, * args là danh sách các tham số được truyền cho hàm đó

h1 trả về giá trị boolean: Đúng nếu hàm f bị dừng khi được gọi trên * args và Sai nếu không (giả sử máy chạy nó có thời gian và bộ nhớ vô hạn và trình thông dịch / trình biên dịch cho ngôn ngữ bạn đang viết biết cách xử lý thời gian và bộ nhớ vô hạn).

Nếu f (* args) sẽ thực hiện cuộc gọi đến h1 hoặc h2, h1 sẽ ném ngoại lệ

h2 hoạt động chính xác như h1 ngoại trừ nếu f thực hiện cuộc gọi đến h1, thì h2 sẽ không ném ngoại lệ

Trong càng ít ký tự càng tốt, viết chương trình không có đầu vào và nên xuất:

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

dựa trên tính hợp lệ của từng phỏng đoán đó

Dưới đây là các liên kết wikipedia giải thích từng phỏng đoán:

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

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

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

Bạn có thể giả sử bất kỳ thư viện số nguyên lớn nào trong bất kỳ ngôn ngữ nào bạn chọn sử dụng sẽ thể hiện thành công các số nguyên lớn tùy ý. Nói cách khác, chúng tôi sẽ giả sử bất kỳ ngôn ngữ / thư viện nào có khả năng diễn đạt 3**(3**10)cũng có khả năng diễn đạt 3**(3**(3**10))trên một cỗ máy đủ mạnh mẽ.

Rõ ràng vì không thể chạy chương trình của bạn, vui lòng cung cấp giải thích về cách thức hoạt động cùng với mã

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')

Tôi đã chọn sử dụng fvà gthay thế h1và h2, theo tiền thưởng; hai dòng bổ sung với 10 tổng ký tự trước là đủ để chuyển đổi: f=:h1, g=:h2.

Và logic thực tế:

Collatz

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

((-:`>:@*&3)^:(~:&1))^:_là thịt của nó; về cơ bản nó là một vòng lặp while (x != 1) x = collatz(x). Nếu chúng ta gọi câu đó reduce:

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

reduce&fcó nghĩa là một động từ đơn âm (xem kết thúc), trong đó reduce&f niff thực sự reduce(n)dừng lại. Các bit loop-y khác, >:^:()^:_về cơ bản là một vòng lặp vô hạn ( >:là gia tăng, ^:có thể được sử dụng như một điều kiện và một trình vòng lặp), phá vỡ khi gặp phải quá trình giảm Collatz không dừng lại. Cuối cùng, gđược gọi để xem nếu vòng lặp vô hạn bao giờ chấm dứt.

Goldbach

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

Logic tương tự, đối với hầu hết các phần, sự khác biệt rõ ràng là tính toán cốt lõi bây giờ +./@1&p:@(-p:@_1&p:). -p:@_1&p:tính toán sự khác biệt giữa một số và tất cả các số nguyên tố nhỏ hơn số đó, 1&p:là một isPrimehàm và +./là logic OR. Do đó, nếu sự khác biệt giữa một số và bất kỳ số nguyên tố nào nhỏ hơn số đó cũng là một số nguyên tố, thì phỏng đoán Goldbach được thỏa mãn và vòng lặp vô hạn tiếp tục. Một lần nữa, fđược sử dụng trong một thử nghiệm cuối cùng về việc liệu vòng lặp vô hạn có thực sự là vô hạn hay không.

Số nguyên tố đôi

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

Tương tự như trên, ngoại trừ (4&p:)^:(2&~:@(-~4&p:)). 4&p:trả về số nguyên tố lớn nhất tiếp theo sau một số đã cho. -~4&p:trả về sự khác biệt giữa một số và số nguyên tố lớn nhất tiếp theo sau nó. 2&~:là != 2. Vì vậy, vòng lặp trong cùng là tương tự while (nextPrimeAfter(p) - p != 2) p = nextPrimeAfter(p).

Ghi chú

Có thể có các lỗi cú pháp, vì tôi đã không kiểm tra có núm vú fvà gđược nêu ra. Ngoài ra, tôi giả định rằng fvà gsẽ có một số dạng có thể được tạo thành với một động từ ở bên trái và một danh từ bên phải, mà tôi không hoàn toàn chắc chắn tuân thủ ngữ pháp J theo bất kỳ cách nào. Chúng vốn là các hàm bậc cao hơn và tôi quá mệt mỏi khi tìm kiếm một cấu trúc phù hợp như trạng từ / liên từ / những gì bạn có vào lúc này, nếu thậm chí có một cấu trúc phù hợp như vậy.

Tôi đã không thực sự sử dụng nối chuỗi thích hợp, và thay vào đó chọn để lại các chuỗi riêng lẻ được đóng hộp. Do đó, đầu ra (giả sử tất cả các thứ khác đều đúng) sẽ là bảng 3 cột, với cột bên trái là "The Collatz", v.v., cột giữa là "Phỏng đoán là" và cột bên phải là "Đúng" / "Sai" .

Tôi cũng khá chắc chắn rằng J không chuyển đổi số nguyên thành độ chính xác tùy ý theo mặc định và hàm tiện ích số nguyên tố quan trọng p:không có miền lớn tùy ý. Mặt khác, do J không hỗ trợ loại số chính xác tùy ý tiêu chuẩn, tôi không chắc sẽ mất bao nhiêu nỗ lực để có được mã này ngang bằng.

Haskell, 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]

bởi vì trong các biến Haskell không chỉ chứa các giá trị, mà cả các tính toán (cái này được gọi là sự lười biếng) Tôi cho phép bản thân đưa ra h1, h2một đối số duy nhất và trả về thời tiết hoặc không đánh giá sẽ dừng lại.

mã hơi vô căn cứ:

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

một chút giải thích:

khi allđược áp dụng vào một danh sách vô hạn, nó sẽ dừng lại một trong những yếu tố của danh sách là Falsedo sự lười biếng (ngắn mạch, đối với tất cả những người không phải là Haskell ngoài kia). chúng tôi sử dụng điều này để tính toán phỏng đoán collatz và phỏng đoán số nguyên tố sinh đôi.

!gói thủ thuật này cùng với in ấn. kết quả là Truekhi fchấm dứt trên tất cả các số 4... (điều này không quan trọng đối với phỏng đoán collatz hoặc phỏng đoán số nguyên tố sinh đôi, bởi vì chúng ta đã biết chúng đúng với số lượng nhỏ như vậy).

mã cho phỏng đoán collatz là "The Collatz"!c. nó in "Giả thuyết Collatz là" và kết quả là thời tiết cchấm dứt trên tất cả các số 4...

mã cho phỏng đoán goldbach là "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]là một hàm được đưa ra n, nếu nó là tổng của hai số nguyên tố, trả về True, nhưng nếu không thì các vòng lặp vô thời hạn. do đó, nếu nó dừng lại cho mọi 4..phỏng đoán của goldbach là đúng.

mã cho phỏng đoán số nguyên tố sinh đôi là "The Twin Primes"! \n->or[p$r+2|r<-[n..],p r]. \n->or[p$r+2|r<-[n..],p r]là một hàm được đưa ra n, nếu có số nguyên tố sinh đôi lớn hơn n, trả về True, nhưng nếu không thì các vòng lặp vô thời hạn. do đó, nếu nó dừng lại cho mọi 4..phỏng đoán nguyên tố sinh đôi là đúng.

Con trăn (965 ký tự)

Vì câu hỏi của tôi là không có tình yêu. Tôi đang đăng giải pháp (không chơi mã) của mình bằng 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))

Nó khá đơn giản.

numCollatzSteps (n) cho biết chuỗi Collatz có bao nhiêu bước cho một n cụ thể. Nó chạy vô tận nếu chuỗi Collatz nói không kết thúc.

findNonHaltingN () đếm ngược lên kiểm tra xem numCollatzSteps chấm dứt cho mọi n. findNonHaltingN chấm dứt khi và chỉ khi tồn tại một n mà numCollatzSteps không chấm dứt.

Vì vậy, chúng tôi có thể kiểm tra xem phỏng đoán Collatz có đúng hay không bằng cách kiểm tra findNonHaltingN () không dừng lại

isPrime (n) kiểm tra xem một số có phải là số nguyên tố hay không bằng cách thấy rằng không có số nguyên dương nào từ 1 đến n-1 chia nó

isSumOf2Primes (n) lặp lại trên tất cả các số nguyên dương giữa 2 và n-2 và kiểm tra xem có ít nhất một số nguyên tố cùng với phần bù của nó không

findNonSum () đếm các số chẵn lên từ 4 cho đến khi nó đạt đến số đầu tiên không phải là tổng của 2 số nguyên tố và sau đó trả về nó. Nếu không có số đó tồn tại, thì nó sẽ tiếp tục vô tận.

Chúng tôi có thể kiểm tra xem phỏng đoán của Goldbach có đúng hay không bằng cách thấy findNonSum không dừng lại.

isSmallTwinPrime (n) trả về true khi và chỉ khi n và n + 2 đều là số nguyên tố

nextSmallTwinPrime (n) trả về số tiếp theo> = n với giá trị nào làSmallTwinPrime là đúng

LargeTwinPrimes () tính từ 2 lần kiểm tra xem nextSmallTwinPrime tạm dừng cho tất cả n. Nếu tiếp theoSmallTwinPrime không dừng lại đối với một số n, thì nó sẽ theo sau các số nguyên tố sinh đôi lớn nhất là n-1 và n + 1 và chúng ta dừng lại ở đó

Sau đó, chúng ta có thể kiểm tra tính hợp lệ của phỏng đoán số nguyên tố sinh đôi bằng cách kiểm tra xem LargeTwinPrimes không bao giờ dừng lại.

APL (234)

Rõ ràng là chưa được kiểm tra, nhưng logic có vẻ như âm thanh. Các lệnh in được bao gồm tất cả, đầu ra là 104ký tự và logic thực tế là 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]

Ung dung:

⍝ 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]