सभी तर्कसंगत संख्याओं की सूची तैयार करें

Question

गणित के सभी में से, हमेशा कुछ प्रमेय होंगे जो सभी सामान्य ज्ञान से परे हैं। इनमें से एक तथ्य यह है कि अनंत के विभिन्न आकार हैं। एक और दिलचस्प तथ्य यह विचार है कि कई असीमताएं जो विभिन्न आकार की लगती हैं, वास्तव में एक ही आकार की होती हैं। पूर्णांक के रूप में कई सम संख्याएँ हैं, जैसे कि परिमेय संख्याएँ हैं।

इस प्रश्न की सामान्य अवधारणा अनंत के विचित्र यथार्थ का सामना करना है। इस चुनौती में, आपका कार्यक्रम एक सूची का उत्पादन करेगा जो:

• किसी भी विशिष्ट समय पर, हमेशा प्रविष्टियों की एक पूरी संख्या होती है
• आखिरकार होते हैं (यदि लंबे समय तक चलने के लिए छोड़ दिया जाता है) पूरी सूची पर एक बार कोई विशिष्ट (गैर-शून्य) तर्कसंगत संख्या
• खाली स्लॉट्स की एक निर्बाध संख्या को शामिल करें (सूची में प्रविष्टियां जो अनावश्यक रूप से 0 पर सेट हैं)
• खाली स्लॉट्स का अनुपात रखें जो 100% की सीमा तक पहुंचते हैं
• प्रत्येक सकारात्मक पूर्णांक N के लिए, N की लगातार खाली स्लॉट्स के साथ अनंत स्थान हैं

चुनौती

आपकी चुनौती यह है कि उस कम से कम संभव कार्यक्रम को लिखना है जो निम्नलिखित नियमों के साथ एक विशेष सूची का उत्पादन करेगा:

1. एक अनुक्रमणिका के साथ सभी प्रविष्टियाँ जो एक वर्गाकार संख्या नहीं है, को शून्य पर सेट किया जाना चाहिए। तो, पहली प्रविष्टि नॉनज़ेरो होगी, दूसरी और तीसरी शून्य होगी, चौथी नॉनज़ेरो होगी, आदि।
2. सभी तर्कसंगत संख्या एक अनुचित अंश (जैसे 4/5 या 144/13) के रूप में होगी जिसे सरल बनाया गया है। अपवाद शून्य है, जो बस होगा 0।
3. सभी (सकारात्मक और नकारात्मक) तर्कसंगत संख्याएं अंततः सूची में दिखाई देनी चाहिए यदि आपका कार्यक्रम लंबे समय तक और पर्याप्त मेमोरी के साथ चलता है। किसी विशेष परिमेय संख्या के लिए, आवश्यक समय मनमाने ढंग से बड़ा हो सकता है, लेकिन हमेशा परिमित, समय की मात्रा।
4. यदि अनंत समय तक चलाया जाता है, तो कोई भी गैर-शून्य तर्कसंगत संख्या कभी भी दो बार नहीं दिखनी चाहिए।

नियम 3 कुछ भिन्नता के लिए अनुमति देता है, क्योंकि विभिन्न संभावित कानूनी आउटपुट की अनंत संख्या है।

आउटपुट लाइनों की एक धारा होगी। प्रत्येक पंक्ति सामान्य रूप की होगी, 5: 2/3जहां पहली संख्या प्रवेश संख्या है, उसके बाद परिमेय संख्या है। ध्यान दें कि 1: 0हमेशा आउटपुट की पहली पंक्ति होगी।

उदाहरण आउटपुट का स्निपेट:

1: 1/1
2: 0
3: 0
4: 2/1
5: 0
6: 0
7: 0
8: 0
9: -2/1
10: 0
etc...

नियम, विनियम और नोट्स

यह कोड गोल्फ है। मानक कोड गोल्फ नियम लागू होते हैं। साथ ही, आउटपुट में अनुमत भिन्नता के कारण, आपको कम से कम यह दिखाने की आवश्यकता है कि आप क्यों मानते हैं कि आपकी सूची में एक बार सभी संभावित तर्कसंगत संख्याएं होंगी, और यह कि आपका समाधान सही है।

EDIT: चूंकि प्राइम नंबर ने चुनौती से ध्यान नहीं हटाया था, इसलिए मैं इसे स्क्वायर नंबरों में बदल रहा हूं। यह एक ही उद्देश्य को पूरा करता है, और समाधान को भी छोटा करता है।

Comments

नियम 1 क्या है? क्या आप चाहते हैं कि लोग पारस्परिकता का परीक्षण करने और तर्कसंगतताओं की गणना करने के लिए दो अलग-अलग कार्यक्रमों को पारस्परिक रूप से गोल्फ करें।

— पीटर टेलर

यह दिखाता है कि पूर्णांक का एक बहुत छोटा हिस्सा अभी भी तर्कसंगत संख्याओं के पूर्ण सेट के समान कार्डिनैलिटी है, और यह खाली स्लॉट के प्रतिशत को दृष्टिकोण (लेकिन कभी नहीं) 100% तक पहुंचने की अनुमति देता है।

— फीनोटपी

मैं यह मान रहा हूं कि कार्यक्रम को निश्चित मात्रा में मेमोरी में चलाने की आवश्यकता है, अर्थात यह मान नहीं सकता कि मशीन हमेशा अधिक आवंटित कर सकती है? इसके अलावा, क्या यह सूची सूचकांक के लिए सी इंट (सी) का उपयोग करने के नियमों के खिलाफ है जब आप जानते हैं कि इसकी परिमित सीमा है? (हालांकि सटीक सीमा कार्यान्वयन के साथ अलग-अलग हो सकती है।) क्या कुछ प्रकार के बिग्नम की आवश्यकता है?

— ब्रेडबॉक्स

@PhiNotPi, ऐसा करने के बहुत सरल तरीके हैं, और यह प्रश्न के अधिक दिलचस्प भाग से एक व्याकुलता है।

— पीटर टेलर

ध्यान दें कि 1: 0हमेशा आउटपुट की पहली पंक्ति होगी। - यह आपके उदाहरण का खंडन करता है और मुझे इससे भी कोई मतलब नहीं है।

— Wrzlprmft

Answer 1

हास्केल, 184 वर्ण

main=putStr.unlines$zip[1..](s>>=g)>>=h
s=(1,1):(s>>=f)
f(a,b)=[(a,a+b),(a+b,b)]
g x@(a,b)=[x,(-a,b)]
h(i,(a,b))=(i^2)%(u a++'/':u b):map(%"0")[i^2+1..i*(i+2)]
i%s=u i++": "++s
u=show

यह कल्किन-विल्फ ट्री की चौड़ाई-पहले का भाग है , जो सभी सकारात्मक परिमेय संख्याओं को एक बार में ही कम कर देता है। यह तब सभी गैर-शून्य तर्कसंगत संख्याओं और पैड को वर्ग प्रविष्टियों के बीच शून्य के साथ कवर करने के लिए सकारात्मक और नकारात्मक के बीच वैकल्पिक करता है।

आउटपुट (संक्षिप्तता के लिए शून्य रेखाओं को छोड़कर):

1: 1/1
4: -1/1
9: 1/2
16: -1/2
25: 2/1
36: -2/1
49: 1/3
64: -1/3
81: 3/2
100: -3/2
...

Answer 2

ऋषि, 103 113 128

ऋषि आसानी से तर्कसंगत को सूचीबद्ध कर सकते हैं! कार्यक्रम की आवश्यकताओं को फिट करने के लिए प्रारूपण, हमेशा की तरह, सब कुछ बर्बाद कर देता है।

for i,q in enumerate(QQ):
 for j in[(i-1)^2+1..i*i]:print'%d:'%j,[0,'%d/%d'%(q.numer(),q.denom())][j==i*i]

ऋषि QQअपनी ऊंचाई के अनुसार गणना करते हैं : जीसीडी कमी के बाद अंश और हर का अधिकतम निरपेक्ष मान।

Comments

आप निम्न को केवल एक बार x.next()उपयोग कर सकते हैं, और printस्कोर को नीचे ला सकते हैं: १२४ x=enumerate(QQ) for i,q in x: for j in[(i-1)^2+1..i*i]: print'%d: '%j,'%d/%d'%(q.numer(),q.denom())if j.is_square()else 0। यह एक टिप्पणी में ठीक से प्रदर्शित नहीं करता है, लेकिन मुझे लगता है कि आप देख सकते हैं कि मेरा क्या मतलब है।

— रेस

BTW, मुझे लगता है कि पहले 4 सकारात्मक तत्वों के बाद, ऋषि की गणना अन्य उत्तरों के समान नहीं है। कैलकिन-विल्फ सूत्र एक अनुक्रम देते हैं जिसमें एक परिमेय का भाजक अगले परिमेय का अंश होता है; जैसे (..., 1/3, 3/2, 2/3, ...), ऋषि की तुलना में ... (..., 1/3, 3/1, 2/3, ...)। मैं ऋषि की गणना के लिए किसी भी दस्तावेज को खोजने के लिए प्रतीत नहीं कर सकता, यह देखने के लिए कि यह कैसे गणना की जाती है।

— रेस

@res, धन्यवाद! मैं प्रिंट स्टेटमेंट को मर्ज करना चाहता था, लेकिन [x..y] नोटेशन का उपयोग करना भूल गया। यहाँ एक और ऋषि उपयोगकर्ता को देखकर बहुत अच्छा लगा!

— बूथ

Answer 3

अजगर, 162

f=lambda n:f(n/2)if n%2 else f(n/2)+f(n/2-1)if n else 1
n=i=1
while 1:
 print'%d:'%i,
 if i-n*n:s=0
 else: n+=1;s='%d/%d'%((-1)**n*f(n/2-1),f(n/2))
 print s
 i+=1

यह रेकिटिंग द कैलक्यून्स एंड विलफ द्वारा दिए गए पुनरावर्तन का उपयोग करता है ।

Answer 4

हास्केल, 55 बाइट्स

mapM_ print$join$iterate(>>=(\x->[x+1,1/(1+1/x)]))[1%1]

आउटपुट

1 % 1
2 % 1
1 % 2
3 % 1
2 % 3
3 % 2
1 % 3
4 % 1
...

1% 1 कल्किन-विल्फ पेड़ की जड़ है; पुनरावृति प्रत्येक नोड के दोनों बच्चों को जोड़ता है; शामिल होने से एकल सूची में स्तरों का पतन होता है।

यदि आप उचित आयात, 0 और नकारात्मक जोड़ते हैं तो 120 वर्ण:

import Data.Ratio
import Control.Monad
main=mapM_ print$0:(join(iterate(>>=(\x->[x+1,1/(1+1/x)]))[1%1])>>=(\x->[-x,x]))

आउटपुट

0 % 1
(-1) % 1
1 % 1
(-2) % 1
2 % 1
(-1) % 2
1 % 2
(-3) % 1
3 % 1
(-2) % 3
2 % 3
(-3) % 2
3 % 2
(-1) % 3
1 % 3
(-4) % 1
4 % 1
...

खाली स्लॉट्स का उत्पादन? यह खराब स्वाद में है :( आपने मुझे "सभी सकारात्मक युक्तियों की सूची" में रखा था।

Comments

mapM_ print$fix((1%1:).(>>= \x->[x+1,1/(x+1)]))47 वर्ण है। से haskellwiki । काम करता है, बिना किसी आयात के, haskell.org की कोशिश में "REPL (अच्छी तरह से, बिना mapM_ printभाग के ...)

— विल नेस

Answer 5

PHP 105 बाइट्स

नोट: इस कोड को सही ढंग से चलाने के लिए iso-8859-1 (asi) के रूप में सहेजा जाना चाहिए। ऑनलाइन व्याख्याकर्ता जो डिफ़ॉल्ट रूप से utf8 के लिए सभी इनपुट को सांकेतिक शब्दों में बदलना (जैसे कि ideone) गलत आउटपुट उत्पन्न करेगा।

<?for($f=µ;$i++<$j*$j||++$j%2||(--$$f?$$f--:$f^=C);)echo"$i: ",$i==$j*$j?$j%2?$x=++$ö.~Ð.++$µ:"-$x":0,~õ;

का उपयोग करते हुए जोर्ज कैंटर की गणना (थोड़ा +/- मूल्यों के लिए संशोधित)।

यदि आपको उपरोक्त कोड को चलाने में समस्या आ रही है (अत्यधिक संदेशों के कारण होने की संभावना है), इसके बजाय इसका उपयोग करें (107 बाइट्स):

<?for($f=µ;$i++<$j*$j||++$j%2||(--$$f?$$f--:$f^=C);)echo"$i: ",$i==$j*$j?$j%2?$x=++$ö.'/'.++$µ:"-$x":0,'
';

Comments

मुझे इस कोड के साथ रन-टाइम त्रुटियां मिलती हैं (जिसमें कुछ अजीब अक्षर होते हैं; उदाहरण के लिए, "$ ö। ~)।")।

— रेस

क्या आप यह प्रदर्शित कर सकते हैं कि यह समाधान काम करता है, आइडोन पर कहता है? मुझे त्रुटियाँ भी मिलती हैं: ideone.com/ru1fo

— mellamokb

जब कई नोटिस संदेश उत्पन्न होते हैं, तो Ideone त्रुटि महसूस करता है: दोनों ~ equal ('/' के बराबर) और ~ "(" \ n "के बराबर) प्रत्येक पुनरावृत्ति पर एक सूचना उत्पन्न करेगा। बेशक, यदि आपके पास नोटिस है, तो यह कोई समस्या नहीं है। दोनों के साथ एक पेस्ट की जगह (107 बाइट्स): ideone.com/lFUbl

— Primo

मैंने अभी देखा है कि Ideone की PHP दुभाषिया गलत आउटपुट उत्पन्न करती है। यदि आप स्थानीय रूप से कोड चलाते हैं, तो आप देखेंगे कि यह सही है। : या, आप यह एक वैध पीएचपी interpretter साथ, इस तरह के अराजकता गोल्फ के प्रदर्शन चेकर के रूप में परीक्षण कर सकते हैं golf.shinh.org/checker.html (एक फ़ाइल और अपलोड करने के लिए इसे बचाने)

— Primo

जब मैं आपके संशोधित कोड को ANSI एन्कोडिंग वाली फ़ाइल में सहेजता हूं, तो यह Anarchy Golf दुभाषिया पर चलता है। हालांकि, अब एक अलग समस्या है: यह इस आवश्यकता का उल्लंघन करता है कि सूची में "कोई गैर-शून्य तर्कसंगत संख्या कभी भी दो बार दिखाई नहीं देनी चाहिए" । वास्तव में, कोड कई बार हर तर्कसंगत को सूचीबद्ध करने के लिए प्रकट होता है; जैसे 1/1, 2/2, 3/3, ... सभी एक ही तर्कसंगत आदि हैं, और 1/2 इसी तरह के लिए, 2/4, 3/6, ...,

— रेस

Answer 6

ऑक्टेव, 168 बाइट्स

a=b=p=1;do for i=(p-1)^2+1:p^2-1 printf("%d: 0\n",i)end
printf("%d: %d/%d\n",p^2,a,b)
a=-a;if a>0do if b==1 b=a+1;a=1;else a++;b--;end until 1==gcd(a,b)end
p++;until 0

समाधान बहुत परिष्कृत नहीं है, यह तर्कसंगत संख्याओं के "कालीन" का सिर्फ एक सरल विकर्ण है, जो सभी भिन्नों को सरल बनाता है। एक सकारात्मक संख्या के बाद a/b, यह विपरीत -a/bहै हमेशा अनुक्रम से जाने से पहले मुद्रित किया जाता है।

चूंकि सभी सकारात्मक सरल अंशों को मुद्रित किया जाएगा और उन लोगों के विपरीत हस्ताक्षरित अंशों को मुद्रित किया जाएगा, और दो अलग-अलग सरल अंशों का कभी भी एक ही मूल्य होना संभव नहीं है, प्रत्येक गैर-शून्य तर्कसंगत संख्या को एक बार बिल्कुल मुद्रित किया जाएगा।

Degolfed:

a=b=p=1
do
    for i=(p-1)^2+1:p^2-1
        printf("%d: 0\n",i)         # p=2,3,4: 1..3,5..8,10..15
    end
    printf("%d: %d/%d\n", p^2,a,b); # p=2,3,4: 4,9,16
    a=-a;
    if a>0                          # the rule is: after a/b, a>0 output -a/b
        do
            if b==1 b=a+1;a=1; else a++;b--; end
        until 1==gcd(a,b)
    end
    p++;
until 0