मिलान तार जिसकी लंबाई एक चौथी शक्ति है

28

इस प्रश्न के दायरे में, हम केवल उन तारों पर विचार करते हैं, जिनमें xबार-बार दोहराए जाने वाले चरित्र का समावेश होता है ।

उदाहरण के लिए:

<empty>
x
xx
xxxxxxxxxxxxxxxx

^{(ठीक है, वास्तव में यह होना जरूरी नहीं है x- कोई भी चरित्र तब तक ठीक है जब तक पूरे स्ट्रिंग में केवल 1 प्रकार का चरित्र न हो)}

अपनी पसंद के किसी रेगुलर एक्सप्रेशन से स्वाद में एक regex लिखें सभी स्ट्रिंग्स जिसकी लंबाई n है मैच के लिए ⁴ कुछ गैर नकारात्मक पूर्णांक के लिए n (n> = 0)। उदाहरण के लिए, लंबाई 0, 1, 16, 81, आदि के तार मान्य हैं; बाकी अमान्य हैं।

^{तकनीकी सीमा के कारण, 128 से बड़े n के मान के खिलाफ परीक्षण करना कठिन है। हालाँकि, आपके रेगेक्स को तार्किक रूप से सही ढंग से काम करना चाहिए।}

ध्यान दें कि आपको अपने regex (Perl उपयोगकर्ताओं को) में मनमाने कोड निष्पादित करने की अनुमति नहीं है। किसी भी अन्य वाक्यविन्यास (देखो-चारों ओर, पीछे-संदर्भ, आदि) की अनुमति है।

कृपया समस्या के बारे में अपने दृष्टिकोण के बारे में एक संक्षिप्त विवरण भी शामिल करें।

^{(कृपया ऑटो रेगेक्स सिंटैक्स स्पष्टीकरण को पेस्ट न करें, क्योंकि वे बेकार हैं)}

regular-expression programming-puzzle

— n̴̖̋h̷͉a̷̭̿h̸̡̅ẗ̵̨d̷̰ĥ̷̳
स्रोत

"xx" वैध नहीं है, क्या यह है?

— केंडल फ्रे

@ केंडलफ्रे: नहींं। यह मान्य नहीं है।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

@nhahtdh क्या आपको लगता है कि इसका कोई संभावित उत्तर है?

— ०२

1

@ टिमवी: हाँ। जावा, पीसीआरई (शायद पर्ल भी, लेकिन परीक्षण नहीं कर सकता), .NET। मेरा हालांकि रूबी / जेएस में काम नहीं करता है।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

1

इस प्रश्न को "उन्नत रेगेक्स-फू" के तहत स्टैक ओवरफ्लो रेगुलर एक्सप्रेशन एफएक्यू में जोड़ा गया है ।

— aliteralmind

21

यह (ir) नियमित अभिव्यक्ति काम करने लगती है।

^((?(1)((?(2)\2((?(3)\3((?(4)\4x{24}|x{60}))|x{50}))|x{15}))|x))*$

यह रेगेक्स PCRE, पर्ल, .NET फ्लेवर के साथ संगत है।

यह मूल रूप से एक "अंतर ट्री" (निश्चित रूप से अगर इसके लिए एक उचित नाम है) का अनुसरण करता है, जो रेगेक्स को बताता है कि अगली चौथी शक्ति के लिए मैच के लिए कितने अधिक x हैं:

1     16    81    256   625   1296  2401 ...
   15    65    175   369   671   1105 ...
      50    110   194   302   434 ...
         60    84    108   132 ...
            24    24    24 ...  # the differences level out to 24 on the 4th iteration

\2, \3, \4दुकानों और अद्यतन अंतर के रूप में क्रमश: 2, 3 और 4 पंक्तियों पर दिखाया गया है।

उच्च शक्तियों के लिए इस निर्माण को आसानी से बढ़ाया जा सकता है।

निश्चित रूप से एक सुरुचिपूर्ण समाधान नहीं है, लेकिन यह काम करता है।

— अस्थिरता
स्रोत

+1। बहुत बढ़िया जवाब। यद्यपि यह उत्तर मेरा अलग है (यह सशर्त रेगेक्स का उपयोग करता है, जबकि मेरा नहीं है), इसमें मेरे समाधान के समान आत्मा है (अंतर ट्री का दोहन और कुछ रेक्सक्स इंजनों के आगे-घोषित बैक-रेफरेंस का उपयोग करना)।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

साफ सुथरा विचार अंतर पेड़। वर्गों के लिए पेड़ 1 4 9 16 ... 3 5 7 ... 2 2 2, सही है?

— 21

@ धन्यवाद धन्यवाद, और हाँ

— अस्थिरता

24

एक और समाधान

यह मेरी राय में, साइट पर सबसे दिलचस्प समस्याओं में से एक है। मुझे इसे शीर्ष पर वापस लाने के लिए डेडकोड को धन्यवाद देना होगा ।

^((^|xx)(^|\3\4\4)(^|\4x{12})(^x|\1))*$

39 बाइट्स , बिना किसी शर्त या दावे के ... जैसे। विकल्प, जैसा कि उनका उपयोग किया जा रहा है ( ^|), एक प्रकार का सशर्त है, "प्रथम पुनरावृत्ति," और "पहले पुनरावृत्ति नहीं" के बीच चयन करने के लिए।

इस रेगेक्स को यहां काम करने के लिए देखा जा सकता है: http://regex101.com/r/qA5pK3/1

पीसीआरई और पायथन दोनों ही रेगेक्स की सही व्याख्या करते हैं, और यह पर्ल में n = 128 तक परीक्षण किया गया है , जिसमें n ⁴ -1 और n ⁴ +1 शामिल हैं ।

परिभाषाएं

सामान्य तकनीक पहले से पोस्ट किए गए अन्य समाधानों की तरह ही है: एक स्व-संदर्भित अभिव्यक्ति को परिभाषित करें जो प्रत्येक बाद के पुनरावृत्ति पर एक असीमित क्वांटिफायर ( ) के साथ आगे के अंतर फ़ंक्शन, डी _एफ के अगले कार्यकाल के बराबर लंबाई से मेल खाती है *। आगे के अंतर समारोह की एक औपचारिक परिभाषा:

$D_f(n)=f(n+1)-f(n)$

इसके अतिरिक्त, उच्चतर ऑर्डर अंतर कार्यों को भी परिभाषित किया जा सकता है:

$D^2_f(n)=D_f(n+1)-D_f(n)$

या, आम तौर पर:

$D^{k}_f(n)=D^{k-1}_f(n+1)-D^{k-1}_f(n)=\sum\limits^k_{i=0}(-1)^i{k\choose i}f(n+k-i)$

आगे के अंतर फ़ंक्शन में बहुत सारे दिलचस्प गुण हैं; यह अनुक्रम है कि व्युत्पन्न निरंतर कार्यों के लिए क्या है। उदाहरण के लिए, एक n वें क्रम के बहुपद का डी _f हमेशा एक n-1 वें क्रम का बहुपद होगा, और किसी भी i के लिए , यदि D _fⁱ = D _f^{i + 1 है} , तो फ़ंक्शन f घातीय है, उसी तरह से कि e ^x की व्युत्पत्ति स्वयं के बराबर है। जिसके लिए सबसे सरल असतत समारोह च = डी _च है 2 ^एन ।

f (n) = एन ²

इससे पहले कि हम उपरोक्त समाधान की जांच करें, चलो कुछ आसान से शुरू करें: एक रेक्सक्स जो स्ट्रिंग से मेल खाता है जिसकी लंबाई एक पूर्ण वर्ग है। आगे अंतर समारोह की जांच:

$D_f=[1,\ 3,\ 5,\ 7,\ 9,\ \ldots]=2n+1$

मतलब, पहला पुनरावृत्ति लंबाई 1 , दूसरी लंबाई 3 की एक स्ट्रिंग , तीसरी लंबाई 5 की एक स्ट्रिंग , आदि से मेल खाना चाहिए, और सामान्य रूप से, प्रत्येक पुनरावृत्ति एक स्ट्रिंग से दो लंबे समय तक मेल खाना चाहिए। संबंधित विवरण इस कथन से लगभग प्रत्यक्ष है:

^(^x|\1xx)*$

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

(1x$_)=~/^(^1|11\1)*$/

इस रेगेक्स को किसी भी n- gonal लंबाई से मेल खाने के लिए सामान्यीकृत किया जा सकता है :

त्रिकोणीय संख्या:
^(^x|\1x{1})*$

वर्ग संख्या:
^(^x|\1x{2})*$

पेंटागनल नंबर:
^(^x|\1x{3})*$

षट्कोणीय संख्या:
^(^x|\1x{4})*$

आदि।

f (n) = एन ³

N ³ पर जा रहा है , एक बार फिर से फ़ॉरवर्ड डिफरेंस फ़ंक्शन की जाँच कर रहा है:

$D_f=[1,\ 7,\ 19,\ 37,\ 61,\ \ldots]=3n^2+3n+1$

यह तुरंत स्पष्ट नहीं हो सकता है कि इसे कैसे लागू किया जाए, इसलिए हम दूसरे अंतर फ़ंक्शन की भी जांच करते हैं:

$D^2_f=[6,\ 12,\ 18,\ 24,\ 30,\ \ldots]=6n+6$

तो, फ़ॉरवर्ड फ़र्क फ़ंक्शन एक स्थिरांक से नहीं बढ़ता है, बल्कि एक रैखिक मूल्य होता है। यह अच्छा है कि D _f² का प्रारंभिक (' -1 th') मूल्य शून्य है, जो दूसरे पुनरावृत्ति पर एक आरंभीकरण को बचाता है। परिणामी रेगेक्स निम्नलिखित है:

^((^|\2x{6})(^x|\1))*$

पहला पुनरावृति 1 से मेल खाएगा , पहले की तरह, दूसरा एक स्ट्रिंग 6 लंबे ( 7 ) से मेल खाएगा, तीसरा 12 स्ट्रिंग ( 19 ), आदि से मेल खाएगा ।

f (n) = n ⁴

एन ^{4 के} लिए आगे का अंतर कार्य :

$D_f=[1,\ 15,\ 65,\ 175,\ 369,\ \ldots]=4n^3-6n^2+4n-1$

दूसरा फॉरवर्ड डिफरेंस फंक्शन:

$D^2_f=[14,\ 50,\ 110,\ 194,\ 302,\ \ldots]=12n^2-24n+14$

तीसरा फ़र्क फ़र्क:

$D^3_f=[36,\ 60,\ 84,\ 108,\ 132,\ \ldots]=24n+36$

अब वह बदसूरत है। डी _एफ² और डी _एफ^{3 के} लिए प्रारंभिक मूल्य क्रमशः गैर-शून्य, 2 और 12 दोनों हैं, जिनके लिए जिम्मेदार होना चाहिए। आप शायद अब तक समझ गए हैं कि रेगेक्स इस पैटर्न का पालन करेगा:

^((^|\2\3{b})(^|\3x{a})(^x|\1))*$

क्योंकि डी _एफ³ की लंबाई से मेल खाना चाहिए 12 सेकंड यात्रा पर, एक जरूरी है 12 । लेकिन क्योंकि यह प्रत्येक अवधि में 24 से बढ़ जाता है , अगले गहरे घोंसले को दो बार लागू करना चाहिए, जिसका अर्थ है b = 2 । अंतिम बात यह है कि डी _एफ² को इनिशियलाइज़ करें । क्योंकि D _f² सीधे D _{f को} प्रभावित करता है, जो कि आखिरकार जिसे हम मैच करना चाहते हैं, उसके मूल्य को इस मामले में सीधे regex में उचित परमाणु को सम्मिलित करके आरंभ किया जा सकता है (^|xx)। अंतिम रेगेक्स तब बन जाता है:

^((^|xx)(^|\3\4{2})(^|\4x{12})(^x|\1))*$

उच्चतर आदेश

एक पांचवें क्रम के बहुपद को निम्नलिखित regex के साथ मिलान किया जा सकता है:
^((^|\2\3{c})(^|\3\4{b})(^|\4x{a})(^x|\1))*$

f (n) = n ⁵ एक काफी आसान एक्सर्साइज़ है, क्योंकि दूसरे और चौथे फॉरवर्ड डिफरेंस फंक्शन के लिए शुरुआती मान शून्य हैं:

^((^|\2\3)(^|\3\4{4})(^|\4x{30})(^x|\1))*$

छह आदेश बहुपद के लिए:
^((^|\2\3{d})(^|\3\4{c})(^|\4\5{b})(^|\5x{a})(^x|\1))*$

सातवें क्रम के बहुपदों के लिए:
^((^|\2\3{e})(^|\3\4{d})(^|\4\5{c})(^|\5\6{b})(^|\6x{a})(^x|\1))*$

आदि।

ध्यान दें कि सभी बहुपद का मिलान इस तरह से नहीं किया जा सकता है, यदि कोई आवश्यक गुणांक गैर-पूर्णांक हो। उदाहरण के लिए, n ^{6 के लिए} आवश्यक है कि a = 60 , b = 8 , और c = 3/2 । यह इस उदाहरण में काम किया जा सकता है:

^((^|xx)(^|\3\6\7{2})(^|\4\5)(^|\5\6{2})(^|\6\7{6})(^|\7x{60})(^x|\1))*$

यहाँ मैंने b को 6 में बदल दिया है , और c से 2 को , जिसमें उक्त मानों के समान उत्पाद है। यह महत्वपूर्ण है कि उत्पाद के रूप में, परिवर्तन नहीं करता है एक · ख · ग · ... नियंत्रण निरंतर अंतर समारोह है, जो छठे क्रम बहुपद के लिए है डी _एफ⁶ । एक प्रारंभ करने में: वहाँ उपस्थित दो प्रारंभ परमाणुओं हैं डी _एफ के लिए 2 , के साथ के रूप में एन ⁴ , और पांचवें अंतर समारोह प्रारंभ करने में अन्य 360 जबकि एक ही समय से लापता दो में जोड़ने, ख ।

— Primo
स्रोत

आपने किन इंजनों पर यह परीक्षण किया है?

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

मैं अंत में समझता हूं कि क्या चल रहा है। वास्तव में केवल एक चीज ही आगे के संदर्भ के लिए समर्थन है। +1

— ǹ̷̰ĥ̷̳h --a̷̭̿h̸̡̅ẗ̵̨́d̴̖̋

@ न्ह्ह्ठ्ठ्ठ आह्ह, आप ठीक कह रहे हैं। फॉरवर्ड-रेफरेंस जरूरी नहीं कि एक सार्वभौमिक विशेषता हो।

— प्राइमो

1

अति उत्कृष्ट! मुझे यह पसंद है कि यह कितना छोटा, सरल और आसान है। अपने उथले घोंसले के शिकार के साथ, हाथ से गणना करना आसान है कि यह कैसे व्यवहार करेगा। इसके अलावा, यह उतनी ही तेजी से होता है जितना कि अस्थिरता और नाहद का समाधान। और मुझे आपके विस्तृत विवरण से प्यार है, प्रदर्शन के साथ कि यह बहुपद के लिए भी बढ़ाया जा सकता है। अगर मैं कर सकता तो मैं बोनस अंक देता।

— डेडकोड

@ लाइने थैंक्स! उम्मीद नहीं थी कि ...

— प्रिमो

13

यहां एक समाधान है जो सशर्त, आगे-घोषित या नेस्टेड बैकरेफरेंस, लुकबाइंड, बैलेंसिंग ग्रुप या रेगेक्स रिकर्सन का उपयोग नहीं करता है। यह केवल लुकहेड और मानक बैकरेफ्रेंस का उपयोग करता है, जो बहुत व्यापक रूप से समर्थित हैं। मुझे रेगेक्स गोल्फ के कारण इन सीमाओं के तहत काम करने की प्रेरणा मिली , जो कि ECMAScript रेगेक्स इंजन का उपयोग करता है।

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

      \2                     \4  \5
^((?=(xx+?)\2+$)((?=\2+$)(?=(x+)(\4+)$)\5){4})*x?$

(कैप्चर समूह regex के ऊपर लेबल किए गए हैं)

रेगुलर एक्सप्रेशन से बस की जगह किसी भी सत्ता में सामान्यीकृत किया जा सकता 4में {4}वांछित शक्ति के साथ।

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

यह प्राइम की सबसे छोटी चौथी शक्ति को बार-बार विभाजित करके काम करता है जो वर्तमान मान द्वारा विभाज्य है। जैसे कि प्रत्येक चरण में भागफल हमेशा एक चौथी शक्ति होती है, यदि मूल मान एक चौथी शक्ति होती है। 1 का एक अंतिम भाग इंगित करता है कि मूल मूल्य वास्तव में एक चौथी शक्ति थी; यह मैच पूरा करता है। शून्य का भी मिलान किया जाता है।

पहले यह \2संख्या की तुलना में सबसे छोटे कारक को पकड़ने के लिए एक आलसी कैप्चर समूह का उपयोग करता है। जैसे कि, यह कारक प्रमुख होने की गारंटी है। उदाहरण के लिए, 1296 (6 ^ 4) के साथ यह शुरू में \2= 2 पर कब्जा कर लेगा ।

फिर, एक पाश है कि 4 बार दोहराया है की शुरुआत में, यह अगर वर्तमान संख्या से विभाज्य है देखने के लिए परीक्षण \2, साथ (?=\2+$)। इस लूप के माध्यम से पहली बार, यह परीक्षण बेकार है, लेकिन इसका उद्देश्य बाद में स्पष्ट हो जाएगा।

इस आंतरिक लूप के अंदर, यह \4संख्या की सबसे बड़ी कारक को अपने से छोटे पर कब्जा करने के लिए लालची कैप्चर समूह का उपयोग करता है (?=(x+)(\4+)$):। वास्तव में यह संख्या को उसके सबसे छोटे अभाज्य कारक से विभाजित करता है \2; उदाहरण के लिए, 1296 को शुरू में \4= 1296/2 = 648 के रूप में कैप्चर किया जाएगा । ध्यान दें कि वर्तमान संख्या का विभाजन \2निहित है। हालांकि यह स्पष्ट रूप से एक कैप्चर समूह में निहित संख्या से वर्तमान संख्या को विभाजित करना संभव है (जो कि मैंने इस उत्तर को पोस्ट करने के चार दिन बाद ही खोजा था), ऐसा करने से यह धीमी और कठिन समझने वाली रेगेक्स के लिए बन जाएगी, और यह नहीं है आवश्यक है, क्योंकि 1 से बड़ा संख्या का सबसे छोटा कारक हमेशा अपने से बड़े कारक के साथ मेल खाता होगा (जैसे कि उनका उत्पाद स्वयं संख्या के बराबर है)।

चूंकि इस तरह का रेगेक्स स्ट्रिंग के अंत में एक स्ट्रिंग छोड़ कर (इसे छोटा बनाकर) केवल "खा सकता है", हमें स्ट्रिंग के अंत तक विभाजन के परिणाम को "स्थानांतरित" करने की आवश्यकता है। यह घटाव (वर्तमान संख्या घटा \4) के परिणाम को कैप्चर समूह \5में और फिर लुकहेड के बाहर, वर्तमान संख्या की शुरुआत के एक हिस्से से मेल खाते हुए किया जाता है \5। यह \4लंबाई में शेष मिलान पर बचे हुए असंसाधित स्ट्रिंग को छोड़ देता है ।

अब यह आंतरिक लूप की शुरुआत में वापस आ जाता है, जहां यह स्पष्ट हो जाता है कि प्राइम फैक्टर द्वारा विभाज्यता के लिए एक परीक्षण क्यों है। हमने सिर्फ संख्या के सबसे छोटे अभाज्य गुणक से भाग दिया है; यदि संख्या अभी भी उस कारक से विभाज्य है, तो इसका मतलब है कि मूल संख्या उस कारक की चौथी शक्ति से विभाज्य हो सकती है। पहली बार यह परीक्षण किया जाता है यह बेकार है, लेकिन अगले 3 बार, यह निर्धारित करता है कि क्या अनुमानित रूप से विभाजित होने का परिणाम \2अभी भी विभाज्य है \2। यदि \2लूप के प्रत्येक पुनरावृत्ति की शुरुआत में यह अभी भी विभाज्य है , तो यह साबित करता है कि प्रत्येक पुनरावृत्ति ने संख्या को विभाजित किया है \2।

हमारे उदाहरण में, 1296 के इनपुट के साथ, यह इस प्रकार होगा:

\2= 2
\4= 1296/2 = 648
\4= 648/2 = 324
\4= 324/2 = 162
\4= 162/2 = 81

अब रेगेक्स पहले चरण में वापस लूप कर सकता है; यह वही है जो फाइनल *करता है। इस उदाहरण में, 81 नया नंबर बन जाएगा; अगला लूप निम्नानुसार जाएगा:

\2= 3
\4=
\481/3 = 27 = 27/3 = 9
\4= 9/3 = 3
\4= 3/3 = 1

अब यह नए चरण के रूप में 1 के साथ पहले चरण में वापस लूप करेगा।

नंबर 1 को किसी भी प्राइम द्वारा विभाजित नहीं किया जा सकता है, जो इसे एक गैर-मैच बना देगा (?=(xx+?)\2+$), इसलिए यह शीर्ष-स्तरीय लूप ( *अंत में एक) से बाहर निकलता है । यह अब पहुंचता है x?$। यह केवल शून्य या एक से मेल खा सकता है। इस बिंदु पर वर्तमान संख्या 0 या 1 होगी और यदि केवल मूल संख्या एक सही चौथी शक्ति थी; यदि यह इस बिंदु पर 0 है, तो इसका मतलब है कि शीर्ष-स्तर का लूप कभी भी किसी चीज से मेल नहीं खाता है, और यदि यह 1 है, तो इसका मतलब है कि शीर्ष-स्तर के लूप ने एक परिपूर्ण चौथी शक्ति को तब तक विभाजित किया है जब तक कि यह किसी भी चीज से विभाज्य नहीं था (या यह पहली जगह में 1 था, जिसका अर्थ है कि शीर्ष-स्तर का लूप कभी भी मेल नहीं खाता)।

49 बाइट्स में बार-बार स्पष्ट विभाजन करके इसे हल करना संभव है (जो सभी शक्तियों के लिए भी सामान्यीकृत है - वांछित पावर माइनस को एक में बदलें {3}), लेकिन यह विधि बहुत दूर, धीमी और एल्गोरिथ्म के एक स्पष्टीकरण का उपयोग करती है। इस उत्तर के दायरे से परे है:

^((x+)((\2(x+))(?=(\4*)\2*$)\4*(?=\5$\6)){3})?x?$

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

— Deadcode
स्रोत

मेरे परीक्षण से (लंबाई 1024 तक), ऐसा लगता है कि यह सही है। हालाँकि, रेगेक्स बहुत धीमा है - लंबाई 16 ^ 4 से मेल खाने में बहुत समय लगता है, इसलिए बड़ी संख्या के लिए सत्यापन करना बहुत कठिन है। लेकिन चूंकि प्रदर्शन की आवश्यकता नहीं है, इसलिए जब मैं आपके regex को समझूंगा, तो मैं इसे बढ़ा दूंगा।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

1

आपकी रेगेक्स और अस्थिरता कमाल की है। उनकी गति और संक्षिप्तता ने मुझे विस्मित कर दिया, दोनों ने मेरे i7-2600k पर 7.5 सेकंड में 100000000 का मिलान किया, इससे भी तेज कि मुझे एक रेगेक्स होने की उम्मीद थी। यहां मेरा समाधान परिमाण के बिल्कुल अलग क्रम पर है, क्योंकि 50625 से मेल करने में 12 सेकंड लगते हैं। लेकिन मेरा लक्ष्य इसके साथ गति नहीं था, बल्कि बहुत अधिक सीमित सेट के उपयोग से न्यूनतम कोड लंबाई में काम पूरा करना था।

— डेडकोड

हमारे जवाब तेजी से हैं, क्योंकि वे मुश्किल से किसी भी पीछे जाते हैं। तुम्हारी पीठ पीछे बहुत कुछ करते हैं ((((x+)\5+)\4+)\3+)\2+$। तुम्हारा भी अपने तरीके से अद्भुत है, क्योंकि मैं यह भी नहीं सोच सकता कि आगे-घोषित बैकरेप्शन के बिना एक वर्ग संख्या का मिलान कैसे किया जाए।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

वैसे, यह सवाल कोड-गोल्फ नहीं है, बल्कि एक पहेली है। मैं कोड लंबाई से समाधान का न्याय नहीं करता।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

ओह। यह बताता है कि आपने क्यों इस्तेमाल किया (?:)। तो क्या मुझे अपना उत्तर अनुकूलित संस्करण को प्राथमिक बनाने के लिए संपादित करना चाहिए?

— डेडकोड

8

समाधान

^(?:(?=(^|(?<=^x)x|xx\1))(?=(^|\1\2))(^x|\3\2{12}xx))*$

यह रेगेक्स जावा, पर्ल, पीसीआरई और .NET फ्लेवर के साथ संगत है। यह रेगेक्स कई प्रकार की विशेषताओं का उपयोग करता है: लुक-फ़ॉरवर्ड, लुक-बैक और फ़ॉर्वर्ड-घोषित बैक-रेफ़रेंस। फॉरवर्ड-घोषित बैक-रेफरेंस प्रकार इस सीमा की संगतता कुछ इंजनों के लिए है।

व्याख्या

यह समाधान निम्नलिखित व्युत्पत्ति का उपयोग करता है।

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

$\ योग \ सीमा_ {i = 1} ^ n (i + 1) ^ 4 - \ योग \ सीमाएँ_ {i = 1} ^ नी ^ 4 = (एन + 1) ^ 4 - 1$
$\ sum \ limit_ {i = 1} ^ ni ^ 4 - \ sum \ limit_ {i = 1} ^ n (i-1) ^ 4 = n ^ 4$

बाईं ओर के योग को जोड़ते हैं:

$\ sum \ limit_ {i = 1} ^ n (4 (i + 1) ^ 3 - 6 (i + 1) ^ 2 + 4 (i + 1) - 1) = (n + 1) ^ 4 - 1$
$\ _ \ _ सीमा_ {i = 1} ^ n (4i ^ 3 - 6i ^ 2 + 4i - 1) = n ^ 4$

2 समीकरणों (शीर्ष समीकरण माइनस बॉटम समीकरण) को घटाएं और फिर बाईं ओर के योगों को जोड़ दें, फिर इसे नीचे सूचीबद्ध करें:

$\ _ \ _ सीमा_ {i = 1} ^ n (12i ^ 2 + 2) = (n + 1) ^ 4 - n ^ ^ - 1$

हम पावर योग के रूप में लगातार चौथी शक्तियों के बीच अंतर प्राप्त करते हैं:

$(n + 1) ^ 4 - n ^ 4 = \ योग \ सीमा_ {i = 1} ^ n (12i ^ 2 + 2 + 1)$

इसका मतलब है कि अंतर लगातार चौथे शक्तियों के बीच होगा वृद्धि (12N द्वारा ² + 2)।

अस्थिरता के जवाब में अंतर पेड़ का जिक्र करना आसान बनाने के लिए :

अंतिम समीकरण का दाहिना हाथ अंतर ट्री में दूसरी पंक्ति है।
वेतन वृद्धि (12n ² + 2) अंतर ट्री में तीसरी पंक्ति है।

पर्याप्त गणित। उपरोक्त समाधान पर वापस जाएं:

1 कैप्चरिंग ग्रुप विषम ^{2 की} गणना के लिए विषम संख्या की एक श्रृंखला रखता है जैसा कि समीकरण में देखा गया है।

सटीक रूप से बोलते हुए, 1 कैप्चरिंग ग्रुप की लंबाई 0 (अप्रयुक्त), 1, 3, 5, 7, ... लूप के रूप में होती है।

(?<=^x)xविषम संख्या श्रृंखला के लिए प्रारंभिक मूल्य निर्धारित करता है। ^सिर्फ यह है कि पहले पुनरावृत्ति में संतुष्ट होने के लिए लुक-फॉरवर्ड की अनुमति दी जाए।

xx\1 2 जोड़ता है और अगले विषम संख्या में आगे बढ़ता है।
2 कैप्चरिंग समूह i ^{2 के} लिए वर्ग संख्या श्रृंखला बनाए रखता है ।

संक्षेप में बोलें, 2 कैप्चरिंग ग्रुप की लंबाई 0, 1, 4, 9, ... लूप के रूप में होगी।

^में (^|\1\2)सेट वर्ग संख्या श्रृंखला के लिए प्रारंभिक मूल्य। और \1\2इसे अगले वर्ग संख्या तक आगे बढ़ाने के लिए विषम संख्या को वर्तमान वर्ग संख्या में जोड़ता है।
तीसरा कैप्चरिंग ग्रुप (किसी भी लुक-फारवर्ड के बाहर और वास्तव में टेक्स्ट का उपभोग करता है) उस समीकरण के पूरे दाहिने-किनारे से मेल खाता है जो हमने ऊपर व्युत्पन्न किया था।

^xमें (^x|\3\2{12}xx)सेट प्रारंभिक मूल्य है, जो + 1समीकरण के दाएँ हाथ की ओर।

\3\2{12}xxसमूह 2 पर कब्जा करने से n ² का उपयोग करके अंतर में वृद्धि (12n ² + 2) जोड़ता है , और एक ही समय में अंतर से मेल खाता है।

यह व्यवस्था संभव है क्योंकि प्रत्येक पुनरावृत्ति में मिलान किए गए पाठ की मात्रा n ^{2 के} निर्माण के लिए लुक-फ़ॉरवर्ड निष्पादित करने के लिए आवश्यक पाठ की मात्रा से अधिक या बराबर है ।

— n̴̖̋h̷͉a̷̭̿h̸̡̅ẗ̵̨d̷̰ĥ̷̳
स्रोत