भगवान के 9 अरब नाम

Question

भगवान के 9 बिलियन नाम आर्थर सी। क्लार्क की एक छोटी कहानी है। यह तिब्बती भिक्षुओं के एक समूह के बारे में है, जिसका आदेश भगवान के सभी संभावित नामों को लिखने के लिए समर्पित है, जो उनके स्वयं के वर्णमाला में लिखे गए हैं। अनिवार्य रूप से, वे अपने वर्णमाला के हर संभव क्रमांकन को लिखने के लिए समर्पित हैं, कुछ नियमों द्वारा प्रतिबंधित। कहानी में, मठ कुछ इंजीनियरों को उनके लिए सभी काम करने के लिए एक कार्यक्रम लिखने के लिए काम पर रखता है। आपका लक्ष्य उस कार्यक्रम को लिखना है।

नियम:

• भिक्षु की वर्णमाला में 13 वर्ण (मेरे अनुमान के अनुसार) का उपयोग किया गया है। आप ABCDEFGHIJKLM13 वर्णों का उपयोग या कुछ अन्य सेट कर सकते हैं ।

• संभावित नाम की न्यूनतम लंबाई 1 वर्ण है। अधिकतम लंबाई 9 वर्ण है।

• कोई भी चरित्र उत्तराधिकार में 3 बार से अधिक नहीं दोहरा सकता है। AAABAएक मान्य नाम है, लेकिन AAAABनहीं है।

• आपके प्रोग्राम को किसी वर्ण के वर्णों (अलग-अलग वर्णक्रम, अर्ध-कॉलोन, जो भी हो) से अलग Aकरने के लिए अनुक्रम में हर संभव नाम (एक फ़ाइल में) प्रिंट करना चाहिए MMMLMMMLM।

• यह कोड-गोल्फ है, और आप किसी भी भाषा का उपयोग कर सकते हैं। 1 जून 2014 तक सबसे छोटा समाधान जीत गया।

संपादित करें: नामों को क्रमबद्ध रूप से सभी अरबों नामों के माध्यम से आगे बढ़ना Aऔर समाप्त होना चाहिए MMMLMMMLM। लेकिन विशेष क्रम आपके ऊपर है। आप सभी 1-अक्षर के नामों को पहले प्रिंट कर सकते हैं, फिर सभी 2-अक्षर के नाम, आदि या आप शुरू होने वाले सभी नामों को प्रिंट कर सकते हैं A, फिर सभी शुरू होने वाले नाम B, या कुछ अन्य पैटर्न। लेकिन एक मानव को फ़ाइल के माध्यम से पढ़ने और यह पुष्टि करने में सक्षम होना चाहिए कि वे सभी हैं और आप जो भी तार्किक क्रम चुनते हैं, वे मानते हैं कि उनके पास समय है।

Comments

क्या आप ब्रह्मांड को खत्म करने की कोशिश कर रहे हैं, सर?

— बोल्क पापुकोग्लू

कहानी के लिए लिंक , रुचि रखने वाले के लिए।

— ThatOneGuy

यह रहा! math.stackexchange.com/a/34292

— edc65

यह पुष्टि करता है कि वर्तमान समस्या में नामों की संख्या वास्तव में 11,459,252,883 है (जैसा कि edc65 के सी प्रोग्राम में पाया गया है )। कार्यान्वयन MathSE पर रॉस Millikan के समाधान लंबाई के साथ नाम की संख्या के लिए निम्नलिखित बहुपद सूत्र उत्पन्न करता है <= 9, चर वर्णमाला आकार कश्मीर के लिए: f(k) = k^9 + k^8 + k^7 - 5*k^6 + k^5 + k^4 + 4*k^3 - 2*k^2 + k। ऋषि कार्यान्वयन: goo.gl/0srwhq

— Res

@ edc65 तो 105.8GBसभी ने कहा और किया! मुझे खुशी है कि सितारे बाहर नहीं गए ... या शायद आपको ऐसा होने के लिए सूची को प्रिंट करना होगा ...?

— recursion.ninja

Answer 1

रूबी, ४६

?A.upto(?M*9){|s|s[/(.)\1{3}|[N-Z]/]||puts(s)}

मेरा मूल, इसी तरह का समाधान लंबा और गलत था (यह आधार 13 संख्याओं को आउटपुट करता है, जो कि अग्रणी शून्य के कारण उनमें से सभी नहीं है), लेकिन मैं इसे यहाँ छोड़ दूँगा क्योंकि इसे वैसे भी वोट मिले थे।

1.upto(13**9){|i|(s=i.to_s 13)[/(.)\1{3}/]||puts(s)}

Comments

खैर मैंने आपका कोड लगभग एक घंटे तक चलाया और इसे देखने और छोड़ने से पहले 2 बिलियन नाम और एक 21 जीबी टेक्स्ट फाइल तक प्राप्त कर ली। मैंने कम करके आंका कि फाइल कितनी बड़ी होगी।

— CSturgess

@CSturgess खैर, रूबी इस तरह की चीज़ों के लिए सबसे तेज़ भाषा नहीं है ...

— बेनजीवेब

@BenjiWiebe लेकिन भिक्षुओं द्वारा हस्तलिखित होने की तुलना में अभी भी तेज है!

— तुरुपाइल

इसे स्वीकार करना क्योंकि इसके पास अधिक वोट हैं।

— CSturgess

इसे एक अलग उत्तर के रूप में पोस्ट नहीं कर रहा है, क्योंकि इसमें बहुत बड़ी मात्रा में मेमोरी की आवश्यकता होती है (~ 30 टीबी, अगर मेरी गणना सही है), लेकिन सिद्धांत रूप में आप इसे 43 अक्षरों में छोटा कर सकते हैंk=*?A..?M*9;puts k-k.grep(/(.)\1{3}|[N-Z]/)

— वेंटरो

Answer 2

सी 140 177 235

अच्छी पुरानी प्रक्रियात्मक शैली, कोई कल्पना नहीं।
यह 8 मिनट में 11,459,252,883 नाम गिनता है।
अगला रनटाइम और नाम फ़ाइल के आकार के साथ संपादित करें। आकाश देखें ...
रनटाइम 57 मिनट, फ़ाइल का आकार 126,051,781,713 (9 वर्ण प्रति पंक्ति)। कृपया मुझे भिक्षुओं का ईमेल पता बताएं, ताकि मैं उन्हें मैन्युअल चेक के लिए ज़िपित फ़ाइल भेज सकूं ...

संपादित करें थोड़ा और अधिक दोहराया, दोहराया पत्रों के लिए जाँच फिर से काम किया।
अभी भी कम से कम नहीं है, लेकिन कम से कम यह समाप्त हो जाता है और आवश्यक आउटपुट उत्पन्न करता है।
रनटाइम 51 मिनट, फ़ाइल का आकार 113,637,155,697 (इस समय कोई प्रमुख खाली नहीं)

एक साइड नोट: जाहिर है कि आउटपुट फाइल बहुत सिक्योर है, फिर भी मुझे 7zip मारना पड़ा, 36 घंटे काम करने के बाद यह 70% था। अजीब।

char n[]="@@@@@@@@@@";p=9,q,r;main(){while(p)if(++n[p]>77)n[p--]=65;else for(r=q=p=9;r&7;)(r+=r+(n[q]!=n[q-1])),n[--q]<65&&puts(n+q+1,r=0);}

Ungolfed

char n[]="@@@@@@@@@@";
p=9,q,r;
main()
{
    while (p)
    {
        if (++n[p] > 77)
        {
            n[p--] = 65; // when max reached, set to min and move pointer to left
        }
        else 
        {
            for (r=q=p=9; r & 7 ;) // r must start as any odd number
            {
                r += r+(n[q]!=n[q-1])); // a bitmap: 1 means a difference, 000 means 4 letters equal
                n[--q] < 65 && puts(n+q+1,r=0);
            }
        }
    }
}

Comments

नहीं #include?

— साइमन कुआंग

@SimonKuang, कुछ संकलक स्वचालित रूप से मूल वाले (stdio) डालेंगे।

— पॉल ड्रेपर

@Simon यह सी मानक है। डिफ़ॉल्ट रूप से, वैश्विक ऑब्जेक्ट्स int हैं और वैश्विक फ़ंक्शन int int। विजुअल स्टूडियो आउटपुट C4013 की 'पुट' के बारे में चेतावनी को परिभाषित नहीं करता है, लेकिन यह वैसे भी मान्य है।

— edc65

एक ट्वीट में फिट बैठता है!

— सिनसुआहंगस

Answer 3

गोल्फस्क्रिप्ट, 58 47 अक्षर

"A"13
9?,{13base{65+}%n+}%{`{\4*/,}+78,1/%1-!},

पीटर टेलर के लिए धन्यवाद, मैं रूबी समाधान की पिटाई नहीं करने से सिप्पुकु से बख्शा गया हूं! कोड को स्वयं 10 तक चलाएं , और यहां प्रमाण है कि यह चार-इन-पंक्ति संख्याओं को छोड़ देता है ।

Comments

आसान बचत: के n+बजाय का उपयोग करें ''+n। मुझे लगता है कि नियंत्रण पात्रों के साथ एक वर्णमाला का उपयोग करने के नियमों के भीतर है, तो आप भी बदल सकते 65+साथ 13+और नामकरण से एक और चरित्र को बचाने के 13:^। और मुझे लगता है कि यह 13,{ stuff [...]हो सकता है 13,1/{ stuff 4*।

— पीटर टेलर

मेरा प्रारंभिक विचार यह था कि बचत एक फिल्टर के माध्यम से होगी, और थोड़े से काम के साथ यह किया जा सकता है। से अपने जीवन को बचाने के लिए 8 की कुल बचत के 13,साथ प्रतिस्थापित किया जा सकता {65+}%n+}%{ backtick {\4*/,}+78,1/%1-!},है।

— पीटर टेलर

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

— सीएसटर्जेस

@PeterTaylor: आप एक सज्जन और विद्वान व्यक्ति हैं!

— क्लाउडीयू

इसके बाद AAAMहोना चाहिए AAABA, और नहीं BAAAB, है ना?

— जस्टफुल

Answer 4

बैश + लिनक्स कमांड लाइन के बर्तन, 43 बाइट्स

jot -w%x $[16**9]|egrep -v "[0ef]|(.)\1{3}"

यह नीचे दिए गए मेरे जवाब के लिए एक समान तकनीक का उपयोग करता है, लेकिन बस आधार 16 में गिना जाता है, और सभी "नाम" युक्त स्ट्रिप्स 0, eया fसाथ ही 3 से अधिक समान अंकों वाले हैं।

भिक्षु की वर्णमाला में निम्नानुसार परिवर्तन करें:

jot -w%x $[16**9]|egrep -v "[0ef]|(.)\1{3}" | tr 1-9a-d A-M

---

बैश + कोरुटिल्स (डीसी और एग्रेप), 46 बाइट्स

संपादित करें - सही संस्करण

dc<<<Edo9^[p1-d0\<m]dsmx|egrep -v "0|(.)\1{3}"

इसे चलाने में थोड़ा समय लगेगा लेकिन मुझे लगता है कि यह सही है।

dcबेस 14. में 14 ^ 9 से 1 तक की गिरावट और बेस में आउटपुट। उदाहरण के लिए 3 से अधिक समान अंकों के साथ संख्याओं को फ़िल्टर करता है। हम "0" अंकों के साथ किसी भी नाम को फ़िल्टर करते हैं, इसलिए हमें नामों में अक्षरों का सही सेट मिलता है।

प्रश्न निर्दिष्ट करता है कि किसी वर्णमाला का उपयोग किया जा सकता है, इसलिए मैं [1-9] [AD] का उपयोग कर रहा हूं। लेकिन परीक्षण के लिए, इसे tr का उपयोग करके [AM] में बदला जा सकता है:

dc<<<Edo9^[p1-d0\<m]dsmx|egrep -v "0|(.)\1{3}" | tr 1-9A-D A-M

यह अनुक्रम देता है:

MMMLMMMLM MMMLMMMLL MMMLMMMLK ... AC AB AA M L K ... C B A

ध्यान दें कि इस dcकमांड को काम करने के लिए टेल रिकर्सियन की आवश्यकता है। यह dc संस्करण 1.3.95 (Ubuntu 12.04) पर काम करता है, लेकिन 1.3 (OSX Mavericks) पर नहीं।

Answer 5

एपीएल (59)

↑Z/⍨{~∨/,↑⍷∘⍵¨4/¨⎕A[⍳13]}¨Z←⊃,/{↓⍉⎕A[1+(⍵/13)⊤¯1⌽⍳13*⍵]}¨⍳9

इसकी अपनी वर्णमाला में लिखा है :) यह थोड़ा लंबा है। इसके साथ चलने में भी लंबा समय लगता है 9, यदि आप चाहें तो परीक्षण करने के लिए इसे कम संख्या के साथ आज़माएं।

स्पष्टीकरण:

• {... }¨⍳9: ⍵1 से 9 तक प्रत्येक संख्या के लिए:
  • ⍳13*⍵: 1 से सभी नंबर प्राप्त करें 13^⍵
  • ¯1⌽: सूची छोड़ दिया करने के लिए 1 से (ताकि हम है बारी बारी से 13^⍵, 1, 2, ..., 13^⍵-1जो में बदल जाता है, 0, 1, 2 ...सापेक्ष 13^⍵)।
  • (⍵/13)⊤: ⍵अंकों का उपयोग करके आधार संख्या 13 में प्रत्येक संख्या को एनकोड करें
  • ⎕A[1+... ]: एक जोड़ें (सरणियाँ 1-अनुक्रमित हैं) और ⎕A(वर्णमाला) में देखें
  • ↓⍉: मैट्रिक्स को कॉलम के साथ वैक्टर के वेक्टर में बदल दें।
• Z←⊃,/: वैक्टर के प्रत्येक आंतरिक वेक्टर को एक साथ मिलाएं, हमें संभावित नामों की एक सूची दें (लेकिन यह अभी तक नियमों को पूरा नहीं करता है)।
• {... }¨: प्रत्येक नाम के लिए, यदि यह 4-दोहराया-वर्ण नियम से मिलता है तो परीक्षण करें:
  • 4/¨⎕A[⍳13]: प्रत्येक वर्ण के लिए, उस वर्ण की 4 स्ट्रिंग बनाएं
  • ⍷∘⍵¨: प्रत्येक स्ट्रिंग के लिए, यदि यह मौजूद है तो परीक्षण करें ⍵
  • ∨/,↑: तार्किक या इन सभी परीक्षणों को लें,
  • ~: और इसका उल्टा करें, 1इसका मतलब है कि यह नियमों को पूरा करता है और 0इसका मतलब यह नहीं है।
• Z/⍨: उन Zसभी तत्वों से चुनें जो रूबल से मिलते हैं
• ↑: हर एक को अलग लाइन पर प्रदर्शित करें

Comments

मैं निराश हूँ। इसकी प्रतिष्ठा को देखते हुए, आपको लगता है कि एपीएल के पास इसके लिए एक-वर्ण समाधान होगा, ताकि कोई भी कीबोर्ड टाइप न कर सके।

— मार्क

@ मर्क, मुझे यकीन है कि एपीएल के पास ऐसा है, लेकिन कोई नहीं जानता कि चरित्र क्या है :)

— पॉल ड्रेपर

इसे एक पत्थर पर लिखना चाहिए, और जब भविष्य के मानवों को यह पता चलता है, तो उन्हें लगता है कि शायद यह सिर्फ आदिम लिखित भाषा है।

— सिनसुआहंगस

Answer 6

पर्ल, 70 68 66 50 अक्षर

$"=",";map/(.)\1{3}/||say,glob$i.="{@a}"for@a=A..M

उपयोग:

$ perl -E 'code' > output_file

अच्छी बात यह है कि प्रिंट बफ़र किए गए हैं, इसलिए आपको पहले छपे हुए सभी 1-कैरेक्टर सॉल्यूशन मिलते हैं, उसके बाद 2-कैरेक्टर के शब्द वगैरह मिलते हैं।

Comments

इस समाधान के बारे में सबसे अच्छी बात यह है कि 1. के बाईं ओर उल्लू है

— डैन हैनली

Answer 7

पर्ल - 35 बाइट्स

#!perl -l
/(.)\1{3}|[N-Z]/||print for A..1x9

एक बाइट के रूप में शेबंग की गिनती।

यह हिस्टोक्रेट के जवाब का एक ढीला अनुवाद है ।

A..1x9थोड़ी विषमता है; इसके लिए आशुलिपि है 'A'..'111111111'। संचायक वास्तव में टर्मिनल मान तक कभी नहीं पहुंचेगा (इसमें केवल ऊपरी-अक्षर वाले अक्षर होते हैं), लेकिन यह अभी भी समाप्त हो जाएगा जब यह 9 वर्णों से अधिक लंबा हो जाएगा। यह, उदाहरण के लिए, 1x4इसके बजाय का उपयोग करके परीक्षण किया जा सकता है ।

Comments

आदर करना! अब मैंने ऐसा क्यों नहीं सोचा? ;)

— ज़ेड

ध्यान दें कि रूबी को इसे पूरा करने के लिए पूरी रेंज नहीं बनानी चाहिए। मेरी टिप्पणी में कोड का एकमात्र कारण इतनी बड़ी मात्रा में मेमोरी की आवश्यकता है कि यह सीमा को एक ऐरे में बदल देता है (ताकि इसका उपयोग कर सकें Array#-)।

— वेंतोरो

@ वेंटरो आह, हाँ, grepऐसा करेंगे। मैं रूबी में पूरी तरह से धाराप्रवाह नहीं हूं।

— प्रिमो

Answer 8

Pyg ( वेय बहुत लंबा, गोल्फ के लिए बनाई गई भाषा के लिए)

फुसफुसाते हुए : 101 ...

Pe(*ItCh(((J(x)for x in ItPr("ABCDEFGHIJKLM",repeat=j)if not An((i*3 in x)for i in x))for j in R(14))))

हालांकि यह करीब है कि मैं वास्तव में इसे पायथन में कैसे करूंगा:

from itertools import *
for i in range(14):
    for j in ("".join(k) for k in product("ABCDEFGHIJKLM",repeat=i) if not any((i*3 in k) for i in k)):
        print j

माइनस कोर्स की लंबी लाइन जटिलता;)

Answer 9

पायथ , 34 वर्ण

Kf<T"n"GJKFbJI>lb9Bb~Jm+bdfXVb*Y3K

स्पष्टीकरण:

Kf<T"n"G        K = list of letters in the alphabet before n.
JK              J = copy of K
FbJ             For b in J:
I>lb9B          If length of b > 9: break
b               print(b)
~J              J+=
~Jm+bd          J+=map(lambda d:b+d,
       XVb*Y3   index of Y*3 in reversed(b)
      fXVb*Y3K  filter for non-zero for Y in K on function index of Y*3 in reversed(b)
~Jm+bdfXVb*Y3K  J+=map(lambda d:b+d, filter(lambda Y:index of Y*3 in reversed(b), K))

Answer 10

पायथन 2 - 212 बाइट्स

from itertools import chain,product as p
a='ABCDEFGHIJKLM'
q={c*4 for c in a}
c=0
for n in chain(*(p(*([a]*l)) for l in range(1,10))):
 n=''.join(n)
 if not any(u in n for u in q):print n
 c+=1
 if c==10**9:break

Answer 11

जाप , 21 बाइट्स

Ep9 osE kè/0|(.)\1{3}

इसे ऑनलाइन आज़माएं! (लिंक केवल तक गणना करता है 14**4।)

यह काम किस प्रकार करता है

Ep9 osE kè/0|(.)\1{3}/

Ep9  14**9
osE  Range from 0 to n (exclusive), mapped through base-14 conversion
kè   Remove elements that match at least once...
/0|(.)\1{3}/  the regex that matches a zero or four times same char.

एक मानक ECMAScript 2017 कार्यान्वयन को जेएस परत (और स्टोर करने के लिए पर्याप्त मेमोरी) के रूप में मानता है, जहां एक Arrayवस्तु की 2**53-1लंबाई अधिकतम हो सकती है ।