एक Halting Oracle के साथ तीन खुली समस्याओं का समाधान

Question

आपको फ़ंक्शंस दिए गए हैं: h1 (f, * args) और h2 (f, * args)

दोनों ऐसी विधियाँ हैं जो पहले से ही आपके लिए परिभाषित हैं (यहाँ तारांकन संख्याओं के तर्क को इंगित करता है)

f एक फ़ंक्शन है, * args उस फ़ंक्शन को दिए जाने वाले मापदंडों की एक सूची है

h1 एक बूलियन मान लौटाता है: सही है अगर फ़ंक्शन f कभी भी रुक जाता है जब * args और फाल्स पर कॉल किया जाता है, अगर ऐसा नहीं होता है (मशीन को चलाने वाले के पास अनंत समय और मेमोरी है और भाषा के लिए दुभाषिया / संकलक जो आप लिख रहे हैं जानता है कि अनंत समय और स्मृति को कैसे संभालना है)।

यदि 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/Collatz_conjecture

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

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

आप किसी भी बड़े पूर्णांक लाइब्रेरी को मान सकते हैं कि आप जिस भी भाषा का उपयोग करना चाहते हैं वह सफलतापूर्वक बड़े पूर्णांक का प्रतिनिधित्व करेगी। दूसरे शब्दों में, हम किसी भी भाषा / पुस्तकालय को मान लेंगे जो व्यक्त 3**(3**10)करने में सक्षम है, 3**(3**(3**10))पर्याप्त रूप से गोमांस मशीन पर व्यक्त करने में भी सक्षम है ।

जाहिर है चूंकि यह आपके कार्यक्रम को चलाने के लिए असंभव है, कृपया एक स्पष्टीकरण प्रदान करें कि यह कोड के साथ कैसे काम करता है

Comments

यह अभी भी एक उद्देश्य स्कोरिंग मानदंड की जरूरत है। इसके अलावा, यह साबित करना कि छद्म कार्यक्रम कार्य वास्तव में चुनौतीपूर्ण हो सकता है।

— श्री लामा

मैंने कहा सबसे कम चरित्र। यह एक कोडगोल्फ समस्या है।

— dspyz

यह इस समस्या के लिए एक दिलचस्प, स्कोरिंग प्रक्रिया है। "सबसे कम अक्षरों में ट्विन प्राइम अनुमान को हल करें।"

— PyRulez

आदमी, क्या एक अच्छा सवाल है

— भूमिगत

Answer 1

जे, 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और चुना ; 10 कुल वर्णों वाली दो अतिरिक्त लाइनें स्विच करने के लिए पर्याप्त हैं: , ।gh1h2f=:h1g=:h2

और वास्तविक तर्क:

Collatz

>:^:((((-:`>:@*&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)रुकावट है। अन्य लूप-वाई बिट्स, >:^:()^:_अनिवार्य रूप से एक अनंत लूप है ( >:वृद्धि है, ^:एक सशर्त और एक पुनरावृत्त के रूप में इस्तेमाल किया जा सकता है) जो कोलाज़ की कमी का सामना करने पर टूट जाता है जो रुकता नहीं है। अंत में gयह देखने के लिए कहा जाता है कि क्या अनंत लूप कभी समाप्त होता है।

Goldbach

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

अधिकांश भाग के लिए एक ही तर्क, स्पष्ट अंतर अब मुख्य गणना है +./@1&p:@(-p:@_1&p:)। -p:@_1&p:किसी संख्या और सभी संख्याओं के बीच के अंतर की गणना उस संख्या से कम है, 1&p:जो एक isPrimeफ़ंक्शन है, और +./तार्किक OR है। इसलिए, यदि किसी संख्या और उस संख्या से कम किसी अभाज्य के बीच का अंतर भी अभाज्य है, तो गोल्डबैच अनुमान संतुष्ट है, और अनंत लूप जारी है। फिर से, 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रूप है कि बाईं तरफ एक क्रिया और सही है, जो मैं नहीं पूरी तरह से किसी भी तरह से जम्मू व्याकरण के लिए सुनिश्चित पालन करता हूँ पर एक संज्ञा के साथ बना जा सकता है के कुछ प्रकार ले जाएगा। वे स्वाभाविक रूप से उच्च क्रम के कार्य कर रहे हैं, और मैं भी एक उचित निर्माण को देखने के लिए बहुत थक गया हूँ क्योंकि इस तरह के एक उपयुक्त निर्माण होने पर, इस समय क्रियाविशेषण / संयोजन / क्या-क्या है।

मैंने वास्तव में उचित स्ट्रिंग संघनन का उपयोग नहीं किया, और इसके बजाय अलग-अलग तारों को छोड़ने का विकल्प चुना। आउटपुट (बाकी सब सही है) इसलिए 3 कॉलम की मेज होगी, जिसके बाएं कॉलम में "The Collatz", आदि हैं, मध्य कॉलम "Conjecture" है, और दायां कॉलम "True" / "False" है। ।

मुझे यह भी पूरा यकीन है कि J पूर्णांकों को डिफ़ॉल्ट रूप से मनमाने ढंग से सटीक रूपांतरित नहीं करता है, और महत्वपूर्ण प्राइम नंबर यूटिलिटी फंक्शन में p:मनमाने ढंग से बड़े डोमेन नहीं होते हैं। दूसरी ओर, यह देखते हुए कि जे एक मानक मनमाना सटीक संख्या प्रकार का समर्थन करता है, मुझे यकीन नहीं है कि इस कोड को बराबर करने में कितना प्रयास लगेगा।

Comments

तो, क्या यह सब के बाद मनमाना परिशुद्धता का समर्थन करता है? मुझे लगता है कि एपीएल उत्तर की तरह प्राइम टेस्ट आसानी से तय हो सकता है।

— jimmy23013

चूँकि मैंने पहले ही लिखा था कि बाउंटी मानदंड (सीजेएम के लिए), मुझे लगता है कि मैं नियमों का पालन करूंगा और हास्केल जवाब दूंगा ... लेकिन मेरे से +1।

— jimmy23013

Answer 2

हास्केल, 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]

क्योंकि हास्केल चर में न केवल मूल्य शामिल हो सकते हैं, लेकिन संगणना (इसे आलस्य कहा जाता है) मैं खुद को 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एक अनंत सूची में लागू किया जाता है, तो यह सूची के तत्वों में से एक iff को रोक देगा False, आलस्य (शॉर्ट-सर्कुलेटिंग, सभी गैर-हास्केल लोगों के लिए वहां से) के कारण। हम इसका उपयोग कोलाजेट अनुमान और जुड़वां प्रिज्म अनुमान की गणना के लिए करते हैं।

!प्रिंटिंग के साथ-साथ इस ट्रिकरी को पैकेज करता है। परिणाम है Trueजब fसभी नंबरों पर समाप्त हो जाता है 4..। (यह कोलाजेट अनुमान या ट्विन प्राइम्स अनुमान के लिए कोई मायने नहीं रखता है, क्योंकि हम पहले से ही जानते हैं कि वे इतनी कम संख्या के लिए सच हैं)।

Collatz अनुमान के लिए कोड है "The Collatz"!c। यह "Collatz अनुमान" प्रिंट करता है और परिणाम है, जो 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, अगर यह दो primes, रिटर्न का योग है 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सही है, लेकिन अन्यथा अनिश्चित काल तक चलता है। इस प्रकार, यदि यह प्रत्येक 4..जुड़वां प्राइम अनुमान के लिए रुक जाता है तो यह सच है।

Comments

क्या आप इस के एक असम्बद्ध संस्करण को भी पोस्ट करना चाहेंगे? (उचित रिक्ति और कुछ प्रकार के हस्ताक्षरों के साथ) मुझे नहीं पता था कि आप सभी को एक पंक्ति में रख सकते हैं जैसे आपने c

— dspyz

प्रायोगिक परीक्षक को [2..n-1] से नहीं जाना चाहिए? (अन्यथा सब कुछ समग्र)

— dspyz

ओह, यह भी, primality या compositeness के लिए p परीक्षण करता है?

— dspyz

मुझे हैस्केल के लिए प्राकृतिक विस्तार पसंद है: h1 यह निर्धारित करता है कि क्या इस थंक का मूल्यांकन रुक जाएगा, या बेहतर अभी तक, एच 1 रिटर्न सभी गणनाओं के लिए सही है जो _ नहीं है। _ _ जहां यह गलत रिटर्न देता है (जब तक कि गणना परिणाम 1 का उपयोग नहीं करता है, जिसमें परिणाम होता है स्वयं _ _ | _) है।

— dspyz

@dspyz हम्म। यह अच्छा है। लेकिन यह हमें इस तथ्य का दुरुपयोग करने की अनुमति देगा कि अपवाद बॉटम हैं, और यह h1 अपवाद तब होता है जब इसका अनुचित उपयोग किया जाता है ... मुझे आश्चर्य है कि वास्तव में यह कितना उपयोगी होगा।

— गर्वित हैकेलर

Answer 3

पायथन (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 समाप्त हो जाता है अगर और केवल अगर कोई n मौजूद है जिसके लिए numCollatzSteps समाप्त नहीं होता है।

तो हम जांच सकते हैं कि क्या Collatz अनुमान सही है कि जाँच से पता चलता है कि NoNHaltingN () रुकता नहीं है

isPrime (n) यह जाँचता है कि क्या कोई संख्या यह देखते हुए है कि 1 से n-1 में कोई धनात्मक पूर्णांक इसे विभाजित नहीं करता है

isSumOf2Primes (n) 2 और n-2 के बीच सभी सकारात्मक पूर्णांकों पर पुनरावृत्त करता है और जाँचता है कि कम से कम एक इसके पूरक के साथ प्रमुख है

findNonSum () 4 से ऊपर की संख्या को तब तक गिनता है जब तक कि यह पहली संख्या तक नहीं पहुंच जाता है जो कि 2 primes की राशि नहीं है और फिर इसे वापस करता है। यदि ऐसी कोई संख्या मौजूद नहीं है, तो यह असीम रूप से जारी रहेगी।

हम जांच कर सकते हैं कि गोल्डबैक का अनुमान सही है या नहीं, यह देखकर कि खोजनम रुक नहीं रहा है।

isSmallTwinPrime (n) सही है और केवल अगर n और n + 2 दोनों ही प्राइम हैं

nextSmallTwinPrime (n) अगला नंबर देता है> = n जिसके लिए isSmallTwinPrime सच है

सबसे बड़ी TwinPrimes () 2 की जाँच से ऊपर की ओर गिना जाता है कि अगलाSmallTwinPrime सभी n के लिए रुकता है। यदि कभी अगला नेस्मॉल्विनप्रेम कुछ एन के लिए रुका नहीं है, तो यह इस प्रकार है कि सबसे बड़े जुड़वां प्राइम एन -1 और एन + 1 हैं और हम वहां रुकते हैं

तब हम जुड़वाँ अपराधों की वैधता की जाँच करके जाँच सकते हैं कि सबसे बड़े टिंटप्रिंट कभी नहीं रुकते।

Answer 4

एपीएल (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]

Ungolfed:

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

Comments

लेकिन क्या एपीएल बड़े पूर्णांक का समर्थन करता है?

— jimmy23013

@ user23013: सिद्धांत रूप में, एपीएल का नंबर प्रारूप एक मनमाना-सटीक फ्लोट है, इस प्रकार, सिद्धांत में यह किसी भी संख्या को संग्रहीत कर सकता है। बेशक, व्यवहार में, एक सीमा है, लेकिन यह कार्यान्वयन-निर्भर है, और सवाल यह कहता है कि यह मानने के आकार की संख्या को संभाल सकता है।

— मारिनस

सवाल यह है कि केवल बड़े पूर्णांक मनमाने ढंग से बड़े हो सकते हैं।

— jimmy23013

@ user23013: इसमें केवल एक ही नंबर टाइप

— marinus

बड़े पूर्णांक का अर्थ आमतौर पर मनमाना सटीक पूर्णांक होता है। जैसा कि प्रश्न में स्पष्ट किया गया है, यह 3**(3**10)( 3*3*10APL में) व्यक्त करने में सक्षम होना चाहिए , जो tryapl.org में DOMAIN ERROR देता है।

— jimmy23013