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

उदाहरण के लिए, "abcabca"यदि हम इसे चरित्र द्वारा पढ़ते हैं , तो स्ट्रिंग एक पैलिंड्रोम नहीं है, लेकिन हमारे पास इसे चंकी पैलिंड्रोम बनाने के तीन अलग-अलग तरीके हैं :

["abcabca"]
["a" "bcabc" "a"]
["a" "bc" "a" "bc" "a"]

जैसा कि आप देख सकते हैं, चंकी पैलिंड्रोमिकनेस एक बहुत ही समावेशी अवधारणा है; हर तार को कम से कम एक तरह से चंकी पैलिंड्रोम में बदला जा सकता है।

कार्य

एक प्रोग्राम या एक फ़ंक्शन लिखें जो इनपुट के रूप में एक स्ट्रिंग प्राप्त करता है और अपने पैलिंड्रोमिक चंकनेस को लौटाता है , अर्थात, इसके विभाजन की संख्या जो पैलिंड्रोमिक सरणियाँ हैं।

परीक्षण के मामलों

 OUTPUT | INPUT
--------+---------------------------------------------
      1 | ""                                          
      1 | "a"                                         
      1 | "ab"                                        
      2 | "aa"                                        
      2 | "aaa"                                       
      3 | "abcabca"                                   
      4 | "abababab"                                  
     28 | "abcabcaabababababcabca"                    
      1 | "bbbbabababbbbababbbaaaaa"                  
     20 | "ababbaaaabababbbaaabbbaa"                  
      5 | "baaabaabababaababaaabbaab"                 
     62 | "bbaaababbabbabbbabaabaabb"                 
      2 | "a man a plan a canal panama"               
     25 | "ama nap lan aca nal pan ama"               
     93 | "SATOR   AREPO   TENET   OPERA   ROTAS"     
    976 | "abcabcaabcabcaabcabcaabcabcaabcabcaabcabca"
  28657 | "ababababababababababaababababababababababa"
2097152 | "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"

अतिरिक्त नियम

आप मान सकते हैं कि इनपुट में 42 या उससे कम मुद्रण योग्य ASCII वर्ण शामिल होंगे, जो वैकल्पिक रूप से आपकी भाषा के स्ट्रिंग सीमांकक और / या एक नई पंक्ति द्वारा घेरे हुए हैं।
प्रत्येक मान्य इनपुट स्ट्रिंग के लिए, आपका कोड मेरी मशीन (Intel Core i7-3770, 16 GiB RAM, Fedora 21) पर एक मिनट से भी कम समय में समाप्त होना चाहिए ।

पर्याप्त एल्गोरिथ्म के साथ, इस समय सीमा का अनुपालन करना आसान होना चाहिए। हालाँकि, आप संभवतः इनपुट स्ट्रिंग के सभी विभाजनों पर पुनरावृति नहीं कर पाएंगे।
यदि आप आउटपुट को STDOUT में प्रिंट करना चुनते हैं, तो इसका अनुसरण एक नई पंक्ति द्वारा किया जा सकता है।
मानक कोड-गोल्फ नियम लागू होते हैं।

— डेनिस
स्रोत

4

पायथ, 40 34 27 22 बाइट्स

Lhsmy:bd_df!xb>TbS/lb2

इसे ऑनलाइन दुभाषिया में आज़माएँ ।

भारी 40 प्रारंभिक संस्करण से नीचे गोल्फ। उपयोगी ऑपरेटरों की एक जोड़ी को इंगित करने के लिए FryAmTheEggman के लिए धन्यवाद (डॉक्स को खोजना मुश्किल है!) जिसने मुझे 6 बाइट्स बचाए हैं। xएक इंडेक्स के बजाय एक सत्य / मिथ्या मूल्य के रूप में व्याख्या करने के द्वारा एक चतुर एकल बाइट बचत के लिए डेनिस के लिए धन्यवाद - !xb>Tbबजाय q<bT>Tb।

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

हम एक फंक्शन को परिभाषित करते हैं yजो एक स्ट्रिंग के chunkiness को bपुनरावर्ती रूप से स्वयं के सबस्ट्रिंग पर कॉल करके निर्धारित करता है b। Pyth में फ़ंक्शंस स्वचालित रूप से याद किए जाते हैं, इसलिए समय के संदर्भ में पुनरावृत्ति बहुत कम है।

L                              def y(b): return ___
                 S/lb2         The range [1,2,...,len(b)/2]
          f!xb>Tb              Filter n for which b[:n] == b[-n:]
   m                           Map each n in the list to...
    y:bd_d                     y(b[d:-d])       
 hs                            Take the sum and add one (implicit return)

— सैम कैपलमैन-लिंग्स
स्रोत

हाँ, सीखने का अधिकांश भाग सांप्रदायिक / परीक्षण और त्रुटि / लेसर पढ़ने, इसे और अधिक गोल्फिंग के साथ अच्छा काम है! :)

— FryAmTheEggman

1

1. आप फ़ंक्शन को सबमिट करके दो बाइट्स बचा सकते हैं। इसके साथ कॉल करने की कोई आवश्यकता नहीं है yz। 2. दो मानचित्रों और एक फ़िल्टर के बजाय, आप एक मानचित्र और एक सशर्त ( लिंक ) का उपयोग कर सकते हैं , जो तीन बाइट्स बचाता है।

— डेनिस

2

CJam ( 41 39 बाइट्स)

qM{_,2/,\f{\~_2$>@2$<@~)/(@=\M*j*}1b)}j

ऑनलाइन डेमो

यह इस अर्थ में "उत्सुक" है कि यह प्रत्येक "केंद्रीय" स्ट्रिंग (यानी मूल स्ट्रिंग के दोनों सिरों से समान संख्या में वर्णों को निकालने का परिणाम) के लिए चंकी पेलिंड्रोम्स की संख्या पाता है, लेकिन क्योंकि यह ऑटो-मेमोनिशन का उपयोग करता है jऑपरेटर प्रत्येक की गणना केवल एक बार की जाती है, एक बहुत तेज़ कार्यक्रम देता है (और गैर-ज्ञापन कार्यान्वयन पर कुछ पात्रों को सहेजता है)।

डेनिस को एक बाइट बचाने के लिए धन्यवाद।

— पीटर टेलर
स्रोत

1

गणितज्ञ, 77 72 57 बाइट्स

1+Tr[#0/@ReplaceList[#,{a__,b___,a__}:>{b}]]&@*Characters

— alephalpha
स्रोत

1

पर्ल, 86 बाइट्स

84 बाइट्स कोड + 2 स्विच

वहाँ एक छोटी विधि है, लेकिन यहाँ जाता है:

perl -lpe 'sub c{my($x,$i)=@_;$x=~/^(.{$i})(.*)\1$/&&c($2,0*++$s)while++$i<length$x}c$_;$_=++$s'

STDIN से इनपुट लेता है, प्रति पंक्ति एक स्ट्रिंग।

स्पष्टीकरण: मानों के लिए 1<=$i<length(input string), /^(.{$i})(.*)\1$/बाएँ और दाएँ विखंडू प्राप्त करने के लिए रेगेक्स का उपयोग करता है और गिनती बढ़ाता है। फिर स्ट्रिंग के केंद्र भाग के लिए पुनरावर्ती करता है।

— svsd
स्रोत