तुकांत योजनाओं को संकलित करें

Question

एक "कविता योजना" अक्षरों की एक स्ट्रिंग aहै z, जैसे कि वर्णों की पहली घटना आरोही क्रम में होती है (बिना अंतराल के) a। उदाहरण के लिए (पहली घटनाओं के साथ चिह्नित):

abccdbebdcfa
^^^ ^ ^   ^

लंबाई की तुकांत योजनाओं की संख्या बेल संख्याओंN द्वारा दी गई है । ( OEIS A000110 ) B(N)

चुनौती

आपका कार्य इन तुकबंदी योजनाओं की एक गणना को लागू करना है, अर्थात पूर्णांक से तुकबंदी योजनाओं के लिए एक विशेषण मानचित्रण। आपको एक सकारात्मक पूर्णांक N <= 26, साथ ही एक गैर-नकारात्मक पूर्णांक दिया गया है 0 <= i < B(N)। वैकल्पिक रूप से, आप रेंज का उपयोग कर सकते हैं 1 <= i <= B(N)। आपको लंबाई की एक कविता योजना का उत्पादन करना चाहिए N, जैसे कि प्रत्येक iएक अलग स्ट्रिंग पैदा करता है।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट ले रहे हैं और STDOUT (या निकटतम विकल्प), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम लिख सकते हैं।

आप कम या ऊपरी केस लेटर्स (लगातार) का उपयोग कर सकते हैं।

आपका कोड उचित समय में किसी भी वैध इनपुट को संभालने में सक्षम होना चाहिए (उदाहरण के लिए कुछ घंटों से अधिक नहींN = 26 , सबसे खराब स्थिति i)। यह उन समाधानों की अनुमति देता है जो बड़े पैमाने पर N(छोटे आधारों के लिए), धीमी भाषाओं में भी, लेकिन उन समाधानों को प्रतिबंधित करते हैं जो बड़े पैमाने पर i(यानी B(N)) के साथ हैं। विशेष रूप से, इसका मतलब है कि Nजब तक आप iयोजनाओं को छोड़ नहीं देते, तब तक आप लंबाई के सभी मान्य तुकांत योजनाओं के माध्यम से पुनरावृति नहीं कर सकते ।

मानक कोड-गोल्फ नियम लागू होते हैं।

उदाहरण

iयोजनाओं का सटीक काम (यानी किसी दिए गए योजनाओं का क्रम N) आप पर निर्भर है। लेकिन यह कहें कि आपने लेक्सोग्राफ़िक ऑर्डरिंग को चुना है, आपका समाधान निम्न तालिका के अनुरूप होना चाहिए ( -अमान्य इनपुट को चिह्नित करते हुए):

N\i 1    2    3    4    5    6    7    8    9    10   11   12   13   14   15
1   a    -    -    -    -    -    -    -    -    -    -    -    -    -    -
2   aa   ab   -    -    -    -    -    -    -    -    -    -    -    -    -
3   aaa  aab  aba  abb  abc  -    -    -    -    -    -    -    -    -    -
4   aaaa aaab aaba aabb aabc abaa abab abac abba abbb abbc abca abcb abcc abcd

यहाँ एक संक्षिप्त सीजेएम स्क्रिप्ट है जो किसी भी दी गई लंबाई के लिए सभी मान्य कविता योजनाएँ बनाती है (लेकिन 10 से अधिक प्रयास न करें या आप थोड़ी देर प्रतीक्षा करेंगे)।

संबंधित चुनौतियां

• एक ग्लिफ़ो कार्यक्रम का अनुवाद करें
• जांचें कि क्या शब्द आइसोमॉर्फ हैं

Comments

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

— मार्टिन एंडर

हालांकि बहुपद समय समाधान के लिए इनाम है, मैं अभी भी समय सीमा को पूरा करने वाले घातीय-समय के समाधान देखना चाहता हूं। (मेरा खुद का गणितज्ञ संदर्भ कार्यान्वयन वर्तमान में अभी भी चुनौती जीत जाएगा।)

— मार्टिन एंडर

B (26) सबसे छोटी बेल संख्या है जो 64-बिट पूर्णांक में फिट नहीं होती है। Meanie। :-(

— एंडर्स केसरग

Answer 1

CJam, 68 66 बाइट्स

r~:W)1a*{__(;\);_,,.*.+}W(*r~{X@\=_2$\/:CX<!{X:C):X;}&C*-C'a+o}W*;

इसे ऑनलाइन आज़माएं।

यह मेरा पहला सीजेएम कार्यक्रम है। इसने मेरे पर्ल समाधान के एक बंदरगाह के रूप में जीवन शुरू किया और शुरू में 130 बाइट्स से अधिक लंबा था। आगे के गोल्फ सुझावों का स्वागत है।

मेरे पर्ल प्रोग्राम के साथ, यह दो भागों में है।

Part 1:
r~:W                                         | Read the first input (n) and store it in W
    )1a*                                     | Create an array of n+1 1s
        {              }W(*                  | Repeat n-1 times:
         __                                  | Duplicate array twice
           (;\);                             | Remove first element of 1st array. Swap
                                             | arrays. Remove last element of 2nd array
                _,,                          | Duplicate array. Count items. Create range
                   .*.+                      | Multiply arrays. Add 1st array to result

Part 2:
r~                                           | Read the second input (i)
   {                                  }W*    | Repeat n times:
    X@                                       | Push y (initially 1). Bring item 2 (last array) to top
     \=                                      | Swap top two items. Pop array[y] (v)
       _2$                                   | Duplicate v. Copy item 2 (i) to top
          \/:CX                              | Swap i & v. i/v. Store in C (c). Push y
               <!{       }&                  | If !(i/v < c):
                  X:C):X;                    | c = y. ++y (store in X)
                           C*-C'a+o          | i -= c * v. Push y. Push "a". Add c. Print
                                         ;   | Discard top item (integer 0)

भाग 1 द्वारा बनाई गई सरणियों को डिबग करने के लिए, भाग 1 ]_`o~और 2 के बीच जोड़ें । यदि n है 5, तो सरणियाँ इस तरह दिखाई देंगी [[1 1 1 1 1 1] [1 2 3 4 5] [2 5 10 17] [5 15 37] [15 52]]:। प्रत्येक सरणी के 0 सूचक उपयोग नहीं किए जाते हैं, वे केवल ऑफ़सेट की गणना नहीं करने से आसान बनाते हैं। सरणियों की गणना इस तरह की जाती है:

[2 5 10 17] [2 5 10 17] [2 5 10 17]        | Duplicate twice
[2 5 10 17] [2 5 10 17] [5 10 17]          | Discard first item of array
[2 5 10 17] [5 10 17] [2 5 10 17]          | Swap last two arrays
[2 5 10 17] [5 10 17] [2 5 10]             | Discard last item of array
[2 5 10 17] [5 10 17] [2 5 10] [2 5 10]    | Duplicate array
[2 5 10 17] [5 10 17] [2 5 10] 3           | Count items in array
[2 5 10 17] [5 10 17] [2 5 10] [0 1 2]     | Integer to range 0 - n-1
[2 5 10 17] [5 10 17] [0 5 20]             | Multiply arrays [2*0 5*1 10*2]
[2 5 10 17] [5 15 37]                      | Add arrays [5+0 10+5 17+20]

यह अगले एक की गणना करते समय पुराने सरणी की एक प्रति रखता है। सरणियों को भाग 2 द्वारा उल्टे क्रम में पढ़ा और खारिज किया जाता है।

Answer 2

अजगर 2, 153

u=[1]*999;i=60;exec"u[i]=i%30*u[i-30]+u[i-29];i+=1;"*900
def x(l,n,a=0):m=u[30*l+a];c=n>=a*m;return'.'*l and chr(65+min(n/m,a))+x(l-1,[n%m,n-m*a][c],a+c)

यह वर्णमाला क्रम और 0-आधारित अनुक्रमण का उपयोग करता है।

आज्ञा देना lअक्षरों का एक प्रत्यय की लंबाई निरूपित और aअलग पत्र कि पूर्ववर्ती भाग में इस्तेमाल किया गया की संख्या को दर्शाते हैं। फिर एक फ़ंक्शन p(l,a)जो शेष अक्षरों को चुनने के तरीकों की संख्या की गणना करता है 40 बाइट्स हो सकते हैं:

p=lambda l,a:l<1or a*p(l-1,a)+p(l-1,a+1)

हालांकि, यह चुनौती के लिए बहुत धीमा है, इसलिए इसके बजाय आवश्यक मानों को पूर्वगामी और uसरणी में संग्रहीत किया जाता है । गणना के प्रत्येक चरण पर, यदि अगला अक्षर aपहले से ही इस्तेमाल में से एक है , n = k * p (l - 1, a) + n ' जहां k अक्षर का 0-अनुक्रमित अक्षर है और n' है nअगले फ़ंक्शन कॉल के लिए मूल्य , जिसमें शेष अक्षरों के बारे में जानकारी शामिल है। यदि एक नए अक्षर का उपयोग किया जाता है, तो n = a * p (l - 1, a) + n ’ ।

Comments

सबसे खराब स्थिति के इनपुट में कितना समय लगता है?

— माइकल क्लेन

@MichaelKlein समय की एक नगण्य राशि।

— फर्सुम

यह वही है जो मैं करने की योजना बना रहा था (इसके अलावा मैंने इसे जेएस के साथ किया होगा)। अच्छी नौकरी! +1

— ETHproductions

Answer 3

हास्केल (जीएचसी 7.10), 150 बाइट्स

s=(1,\_->[]):s
k!((y,b):l@((x,a):_))|let h i|i<x=k:a i|(p,q)<-divMod(i-x)y=p:b q=(x+k*y,h):(k+1)!l
n#i=(['a'..]!!).fromEnum<$>snd(iterate(0!)s!!n!!0)i

ऑपरेटर वें (शून्य-अनुक्रमित) लंबाई की कविता योजना की n # iगणना करता है । यह O (n²) (बड़े-पूर्णांक) परिचालनों में चलता है, जो स्वचालित संस्मरण के लिए हास्केल की आलसी अनंत सूचियों का लाभ उठाता है। नमूना चलता है:in

*Main> 26 # 0
"abcdefghijklmnopqrstuvwxyz"
*Main> 26 # 1
"abcdefghijklmnopqrstuvwxya"
*Main> 26 # 2
"abcdefghijklmnopqrstuvwxyb"
*Main> 26 # 49631246523618756271
"aaaaaaaaaaaaaaaaaaaaaaaabb"
*Main> 26 # 49631246523618756272
"aaaaaaaaaaaaaaaaaaaaaaaaab"
*Main> 26 # 49631246523618756273
"aaaaaaaaaaaaaaaaaaaaaaaaaa"
*Main> [1 # i | i <- [0..0]]
["a"]
*Main> [2 # i | i <- [0..1]]
["ab","aa"]
*Main> [3 # i | i <- [0..4]]
["abc","aba","abb","aab","aaa"]
*Main> [4 # i | i <- [0..14]]
["abcd","abca","abcb","abcc","abac","abaa","abab","abbc","abba","abbb","aabc","aaba","aabb","aaab","aaaa"]

(यदि अधिकतम एन 26 के बजाय 25 थे, तो .fromEnumहटाया जा सकता है, क्योंकि बी (25) 64-बिट में फिट बैठता है Int)

Comments

अच्छा लग रहा है। क्या आप आसान ग्रोकिंग के लिए कम गोल्फ वाले संस्करण को जोड़ना पसंद करेंगे?

— माइकल क्लेन

Answer 4

पर्ल 257 + 1 (-पी ध्वज) = 258

पर्ल 182 + 10 (-पीएमबिनम झंडे) = 192

($n,$i)=split;@m=[@a=(1)x($n+1)];while($a[2]){push@m,[@a=map{$a[$_]*$_+$a[$_+1]}0..$#a-1]}$_='';$y=1;while($w=pop@m){$c=int($i/($v=$$w[$y]));$c=$y++if($c>=$y);$i-=$c*$v;$_.=chr$c+65}

कई बाइट्स बचाने के लिए देव-नुल के लिए धन्यवाद ! मैंने अब इसे फिर से लिखा है जो मैंने CJam संस्करण को करने से सीखा है।

आरोही वर्णमाला क्रम में गणना करता है, 0 अनुक्रमित।

दो भाग: भाग 1 128 90 बाइट्स है और भाग 2 के लिए एक मैट्रिक्स की गणना करता है। भाग 2 129 92 बाइट्स है और प्रत्येक अक्षर की गणना के लिए कुछ सरल गणित करता है। यदि मैं मैट्रिक्स से छुटकारा पा सकता हूं और इसे दो सरल संख्याओं के साथ बदल सकता हूं, तो मैं प्रत्येक संख्या के लिए मैट्रिक्स के माध्यम से एक पथ की गणना कर सकता हूं और बहुत सारे बाइट्स बचा सकता हूं! जाहिर है, यह विचार काम नहीं करता है!

दुर्भाग्य से, यह i9007199254740992 से अधिक के मूल्यों के लिए सही कविता का उत्पादन नहीं करता है , लेकिन यह कम मूल्यों के साथ खूबसूरती से काम करता है! मैंने 11 बाइट्स की कीमत पर Bignum लाइब्रेरी को जोड़ा है। यह कमांड लाइन से चलाया जाता है perl -pMbignum bell-rhyme.pl। -pMbignum = 10 बाइट्स। यह किसी भी इनपुट मूल्य के लिए बहुत तेज़ है।

Answer 5

Oracle SQL 11.2, 412 284 283 बाइट्स

WITH a AS(SELECT CHR(96+LEVEL)d,LEVEL b FROM DUAL CONNECT BY LEVEL<=:i),v(s,c,n)AS(SELECT d,1,1 FROM a WHERE b=1 UNION ALL SELECT s||d,b,LENGTH(REGEXP_REPLACE(s||d,'([a-z])\1+','\1'))FROM v,a WHERE(b<=n OR b=c+1)AND LENGTH(s)<:n)SELECT s FROM v WHERE:n=LENGTH(s)AND:i<=:n ORDER BY 1;

दुर्भाग्य से यह केवल 8 की लंबाई तक चलता है। किसी भी अधिक मूल्य के परिणाम: ORA-01489: स्ट्रिंग कॉन्कैटेन का परिणाम बहुत लंबा है

संयुक्त राष्ट्र के golfed

WITH a AS(SELECT CHR(96+LEVEL)d,LEVEL b FROM DUAL CONNECT BY LEVEL<=:i),
v(s,c,n) AS
(
  SELECT d,1,1 FROM a WHERE b=1
  UNION ALL
  SELECT s||d,b,LENGTH(REGEXP_REPLACE(s||d,'([a-z])\1+','\1')) 
  FROM v,a 
  WHERE (b<=n OR b=c+1) AND LENGTH(s)<:n
)
SELECT s FROM v WHERE LENGTH(s)=:n AND :i<=:n ORDER BY 1;

एक दृश्य उत्पन्न करता है: ख में i अक्षर और a में उनका मान।

पुनरावर्ती दृश्य v मानक v के रूप में निर्मित स्ट्रिंग को लेता है, c में प्रयुक्त अंतिम अक्षर का मान और n में प्रयुक्त सबसे बड़े अक्षर का मान। N पैरामीटर किसी डुप्लिकेट पत्र के बिना स्ट्रिंग की लंबाई के बराबर है, जो कि regex के लिए है।

यदि कोई अक्षर वैध है तो उसका मूल्य <= पहले से उपयोग किए गए सबसे बड़े अक्षर का मूल्य है या यह उपयोग किया जाने वाला अगला अक्षर है।

किसी तरह क्वेरी को चलने के लिए LENGTH (s) <: n भाग की आवश्यकता होती है, मुझे कुछ याद रखना चाहिए कि क्वेरी कैसे काम करती है।

मुख्य चयन में अमान्य इनपुटों को छानने का ध्यान रखा जाता है और लक्षित लक्ष्य तक पहुँचने से पहले निर्मित छोटे तारों को देखा जाता है।

412 बाइट्स संस्करण

WITH a AS(SELECT * FROM(SELECT d,b,ROW_NUMBER()OVER(PARTITION BY b ORDER BY d)l FROM(SELECT CHR(64+DECODE(MOD(LEVEL,:i),0,:i,MOD(LEVEL,:i)))d,CEIL(LEVEL/:i)b FROM DUAL CONNECT BY LEVEL<=:i*:n))WHERE l<=b),v(s,c,p)AS(SELECT d,1,l FROM a WHERE b=1 UNION ALL SELECT s||d,c+1,l FROM v,a WHERE c+1=b AND(l<=LENGTH(REGEXP_REPLACE(s,'([A-Z])\1+','\1'))OR l=p+1))SELECT s FROM v WHERE LENGTH(s)=:n AND :i<=:n ORDER BY 1;

26 के साथ 412 बाइट्स क्वेरी की कोशिश न करें। यह डेटाबेस को प्रतिबंधित मोड में रखता है, कम से कम मेरे xe संस्करण पर एक मैकबुक पर डॉक कंटेनर में चल रहा है। मैं काम पर एक्सडाटा पर कोशिश कर सकता था, लेकिन दुख की बात है कि मुझे अभी भी जीविका के लिए काम करने की जरूरत है।

Answer 6

गणितज्ञ, 136 बाइट्स

(For[j=2^#-1;t=#2,c=1;m=0;x=t;r=If[#>0,++m,c*=m;d=x~Mod~m+1;x=⌊x/m⌋;d]&/@j~IntegerDigits~2;;c<=t,t-=c;--j];FromCharacterCode[r+64])&

पूर्णता के लिए, यहाँ मेरा गोल्फ संदर्भ कार्यान्वयन है। मौजूदा जवाबों के विपरीत, यह बहुपद समय में नहीं चलता है (यह Nबेस 2 के साथ घातीय है ) लेकिन समय की कमी को पूरा करता है (सबसे बुरा मामला अभी भी आधे घंटे से कम समय में चलेगा)।

विचार यह है:

• प्रत्येक तुकबंदी योजना के लिए हम उन पदों की पहचान कर सकते हैं जहां अब तक अधिकतम चरित्र बढ़ता है:

  ABCDEFGHDIJDEKBBIJEIKHDFII
  ^^^^^^^^ ^^  ^
  

  हम उन चिह्नों को एक द्विआधारी संख्या के रूप में मान सकते हैं जो ऐसी सभी संरचनाओं पर पुनरावृति करना आसान बनाता है। हमें 2 ^n-1 से 2 ⁿ (या दूसरा तरीका राउंड) से पुनरावृति करने की आवश्यकता है, जहां घातीय समय जटिलता आती है।

• ऐसी प्रत्येक संरचना के लिए यह निर्धारित करना आसान है कि ऐसे कितने तार हैं: केवल चिह्नों के बीच अंतराल को स्वतंत्र रूप से चुना जा सकता है, और अंतराल के सामने अधिकतम हमें बताता है कि प्रत्येक स्थिति में कितने भिन्न वर्ण मान्य हैं। यह एक साधारण उत्पाद है। यदि यह संख्या इससे छोटी है i, तो हम इसे घटाते हैं i। अन्यथा, हमने अनुरोधित कविता योजना की संरचना को पाया है।
• दी गई संरचना में योजनाओं की गणना करने के लिए, हम बस iमिश्रित आधार संख्या के रूप में (या इसके अवशेष क्या हैं) का प्रतिनिधित्व करते हैं , जहां अंकों के वजन शेष पदों में अनुमत वर्णों की संख्या से निर्धारित होते हैं।

मुझे आश्चर्य है कि यह कुछ अन्य भाषाओं में एक छोटे से समाधान के लिए अनुमति देगा जो प्रस्तुत किए गए थे क्योंकि इसके लिए किसी भी अनुमोदन या पूर्व-भुगतान की आवश्यकता नहीं है।