h1 (f, * args) 및 h2 (f, * args) 함수가 제공됩니다.

둘 다 이미 정의 된 메소드입니다 (여기서 별표는 가변 개수의 인수를 나타냅니다)

f는 함수이고 * args는 해당 함수에 전달할 매개 변수의 목록입니다.

h1은 부울 값을 반환합니다. * args에서 호출 될 때 함수 f가 중지되면 True이고 그렇지 않으면 False입니다 (실행중인 시스템에 시간과 메모리가 무한하고 작성중인 언어에 대한 인터프리터 / 컴파일러가 있다고 가정). 무한한 시간과 메모리를 처리하는 방법을 알고 있습니다).

f (* args)가 h1 또는 h2를 호출하면 h1에서 예외가 발생합니다.

f가 h1을 호출하면 h2에서 예외가 발생하지 않는다는 점을 제외하고 h2는 h1과 똑같이 동작합니다.

가능한 적은 문자로 입력하지 않고 출력해야하는 프로그램을 작성하십시오.

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

각 추측의 타당성에 기초합니다.

다음은 각 추측을 설명하는 위키피디아 링크입니다.

http://en.wikipedia.org/wiki/Collatz_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 n진정한 iff가 reduce(n)멈추는 곳. 다른 루프 -y 비트 >:^:()^:_는 본질적으로 정지되지 않는 Collatz 감소에 직면 할 때 무한 루프 ( >:증가됨, ^:조건부 및 반복자로 사용될 수 있음)입니다. 마지막으로 g무한 루프가 종료되는지 확인하기 위해 호출됩니다.

골드 바흐

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

동일한 논리, 대부분 핵심 계산의 명백한 차이점은 이제 +./@1&p:@(-p:@_1&p:)입니다. -p:@_1&p:다수 이하 그 숫자보다 모든 소수의 차이가 계산 1&p:인 isPrime기능 및 +./논리적 OR. 따라서 숫자와 소수보다 작은 소수의 차이도 소수이면 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 개의 열 테이블이됩니다. .

또한 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 변수에는 값뿐만 아니라 계산 (laziness라고 함)이 포함될 수 있기 때문에 h1, h2단일 인수를 취하고 날씨를 반환하거나 평가가 중단되지 않습니다.

다소 ungolfed 코드 :

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 사람들에 대한 단락) 목록의 요소 중 하나가 멈 추면 중단됩니다 . 우리는 collatz 추측과 쌍둥이 프라임 추측을 계산하기 위해 이것을 사용합니다.

!이 속임수를 인쇄와 함께 포장합니다. 결과는 모든 숫자에서 종료 True될 때 f입니다 4... (이것은 collatz 추측이나 쌍둥이 프라임 추측에는 중요하지 않습니다. 우리는 이미 그러한 숫자가 적다는 것을 알고 있기 때문입니다).

collatz 추측의 코드는 "The Collatz"!c입니다. "Collatz 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]는 n두 소수의 합이면을 반환 True하고 그렇지 않으면 무한정 반복 되는 함수입니다 . 따라서 모든 4..goldbach의 추측에 대해 그것이 멈 추면 사실입니다.

쌍둥이 소수 추측에 대한 코드는 "The Twin Primes"! \n->or[p$r+2|r<-[n..],p r]입니다. \n->or[p$r+2|r<-[n..],p r]는 n보다 큰 쌍 소수가 있으면 nTrue를 반환하지만 그렇지 않으면 무한정 반복 되는 함수입니다 . 따라서 모든 4..쌍둥이 프라임 추측에 대해 중단되면 사실입니다.

파이썬 (965 자)

내 질문은 사랑을 얻지 못하기 때문에. 파이썬으로 (비 골프) 솔루션을 게시하고 있습니다.

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

상당히 간단합니다.

numCollatzSteps (n)은 특정 n에 대한 Collatz 시퀀스가 ​​몇 단계를 수행하는지 나타냅니다. Collatz 시퀀스가 ​​종료되지 않으면 무한대로 실행됩니다.

findNonHaltingN ()은 numCollatzSteps가 모든 n에 대해 종료되는지 점검하여 상향 계산합니다. findNonHaltingN은 numCollatzSteps가 종료되지 않는 n이있는 경우에만 종료됩니다.

findNonHaltingN ()이 멈추지 않는지 확인하여 Collatz 추측이 참인지 확인할 수 있습니다.

isPrime (n)은 1에서 n-1 사이의 양의 정수가 나누지 않음을 확인하여 숫자가 소수인지 확인합니다.

isSumOf2Primes (n)은 2와 n-2 사이의 모든 양의 정수를 반복하고 적어도 하나의 보수와 함께 소수인지 확인합니다.

findNonSum ()은 짝수를 두 소수의 합이 아닌 첫 번째 숫자에 도달 할 때까지 4에서 위쪽으로 세어 반환합니다. 그러한 숫자가 존재하지 않으면 무한대로 계속됩니다.

findNonSum이 멈추지 않음을 확인하여 Goldbach의 추측이 맞는지 확인할 수 있습니다.

isSmallTwinPrime (n)은 n과 n + 2가 모두 소수 인 경우에만 true를 반환합니다.

nextSmallTwinPrime (n)은 isSmallTwinPrime이 true 인 다음 숫자> = n을 리턴합니다.

biggestTwinPrimes ()는 nextSmallTwinPrime이 모든 n에 대해 중지되는지 확인하는 2에서 위쪽으로 계산합니다. nextSmallTwinPrime이 일부 n 동안 정지하지 않으면 가장 큰 트윈 프라임은 n-1 및 n + 1이며 거기서 우리는 멈 춥니 다.

그런 다음 가장 큰 트윈 프림이 멈추지 않는지 확인하여 트윈 프라임 추측의 유효성을 확인할 수 있습니다.

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]