दहाड़ते तार

28

एक स्ट्रिंग दानेदार है अगर इसे उपप्रकार में विभाजित किया जा सकता है, जिनमें से प्रत्येक एक तार लगातार दो बार दोहराया जाता है। उदाहरण के लिए, के aabaaababbbabaरूप में pairable है:

aaba aaba
b b
ba ba

की एक गैर रिक्त स्ट्रिंग को देखते हुए aकी और bकी, उत्पादन एक Truthy मूल्य अगर यह के pairable और एक Falsey मूल्य अगर यह नहीं है।

Pairable:

aa
abaaba
bbababbb
aabaaababbbaba
babababa
bbbbbbbbbbbb
aaababbabbabbbababbaabaabaababaaba
aaaabaab

नहीं पहनने योग्य:

a
ba
baab
abaabaaba
bbbbbbbbbbbbbbb
baababbabaaaab
aaaaabbaaaaa

जब आप पहले से ही अपनी भाषा में एक छोटा सा रेग्जीन उत्तर दे रहे हों, तो मैं आपको गैर-रेगेक्स-आधारित समाधानों के साथ आने के लिए प्रोत्साहित करता हूं। आप उन्हें "नो रेगेक्स" के रूप में चिह्नित कर सकते हैं। रेगेक्स से मेरा मतलब है कि बिल्ट-इन स्ट्रिंग पैटर्न सबसिस्टम से मेल खाता है।

लीडरबोर्ड:

कोड स्निपेट दिखाएं

code-golf  string  subsequence 
— XNOR
स्रोत
क्या हम इसके अलावा कुछ और उपयोग कर सकते हैं ab?
— आउटगोल्फ
अगर बब्बाबब ग़ज़ब का है, तो बाअब और आआआआआआआआआआआआआआआआआआआआआआआआआआआआआआअआअआअआअआआआआआआआआआआआआआआआसससससससस और बआआआआआआआआआआआआआआआअअअअदहअबअआआआआआआआआआआआअआअअअअअकअआआआआआआआआअअअअअयदआबअआआआआआआआआआअअअअअद नहीं)
— 14
@rnso मेरी समझ से, bbabbbb को 3 जोड़े: bb, abab और bb के रूप में देखा जा सकता है, जो मूल स्ट्रिंग बनाने के लिए उस क्रम में सम्‍मिलित करता है, जबकि अन्य दो नहीं कर सकते।
— सनी पुंन
प्रश्न के अनुसार "जिनमें से प्रत्येक (स्थानापन्न) एक स्ट्रिंग है जिसे दो बार CONSECUTIVELY दोहराया गया है" और वह bbababbb से संतुष्ट नहीं है। अन्यथा, baab को भी baab में विभाजित किया जा सकता है, और aaaaabbaaaaa को aaaaa bb aaaaa को विभाजित किया जा सकता है।
— 18
@rnso यकीन नहीं है कि आप वहाँ क्या मतलब है। निरंतर रूप से, मेरा मतलब है कि दो दोहराव एक दूसरे के बगल में हैं। "बा बी" में, दो बी को ए द्वारा अलग किया जाता है, ताकि काम न हो।
— 21

जवाबों:

11

पायथन 2, 68 63 बाइट्स

f=lambda s,n=1:s==2*s[:n]or''<s[n:]>-f(s,n+1)<f(s[n:])*f(s[:n])

सही या गलत लौटाता है । Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत
4
यह वास्तव में स्वच्छ पुनरावृत्ति है, जो केंद्र के विभाजन और केंद्र के विभाजन दोनों के लिए सूचकांक का उपयोग करता है। यह हास्यास्पद है कि सत्यता को किसी चीज से कम होने के रूप में जांचा जाता है। मुझे कुछ सुधार दिखाई दे रहे हैं ...
— xnor
8

रेटिना , 11 बाइट्स

^((.+)\2)+$

सभी परीक्षण मामलों की कोशिश करो। पहले दो बाइट्स इसे बहु-पंक्ति बनाते हैं।

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

— FryAmTheEggman
स्रोत
2
डंगिट, मैं इसे पोस्ट करने के लिए 3 सप्ताह का इंतजार कर रहा था ...
— ETHproductions
2
— xnor
5
ओह! मैं केवल उसे 10 सेकंड से हराता हूं, ... मुझे यकीन है कि अगर मैं हेक्सागोनी का जवाब लिखूंगा तो वह मुझे माफ कर देगा!
— FryAmTheEggman
5
@FryAmTheEggman मैं इसके लिए तत्पर हूं। :)
— मार्टिन एंडर
2
यह पर्ल के साथ बिल्कुल वैसा ही है:perl -pE '$_=/^((.+)\2)+$/'
— दादा
8

जेली , 10 बाइट्स

ẆŒPẋ€€2F€ċ

बिल्कुल कुशल नहीं ... इसे ऑनलाइन आज़माएं!

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

ẆŒPẋ€€2F€ċ  Main link. Argument: s (string)

Ẇ           Window, generate the array of all substrings of s.
 ŒP         Powerset; generate all subarrays of substrings of s.
   ẋ€€2     Repeat each substring in each subarray twice.
            For example, ["ab", "a", "b"] becomes ["abab", "aa", "bb"].
       F€   Flatten the subarrays by concatenating their strings.
         ċ  Count how many times s appears in the generated strings.
— डेनिस
स्रोत
यह ... अक्षम लगता है। एक उचित समय सीमा में इस इनपुट को कब तक संभाल सकते हैं?
— जॉन ड्वोरक
1
यह बेहद अक्षम है ( ओ (2 ^ एन ^ 2) , मुझे लगता है)। मुझे स्थानीय जांच करनी होगी। टीआईओ मेमोरी की लंबाई 6 के तार के लिए बाहर चलाता है ।
— डेनिस
8
मेरी मशीन पर लंबाई 6 की एक स्ट्रिंग में 3:20 मिनट लगते हैं और इसके लिए 6 जीबी मेमोरी की आवश्यकता होती है।
— डेनिस
1
@ डेनिस चलो एक लंबाई 100 इनपुट तब नहीं करते हैं , क्योंकि सब कुछ दुर्घटनाग्रस्त हो जाएगा। हाँ, यहां तक ​​कि TIO।
— को आउटगोल्फर
@EriktheGolfer यह एक अच्छा विचार है क्योंकि यह अनावश्यक रूप से अन्य उपयोगों के लिए TIO को धीमा कर देगा, लेकिन यह इसे क्रैश नहीं करेगा। जैसे ही सिस्टम मेमोरी से बाहर निकलता है, प्रक्रिया ओओएम द्वारा बस मार दी जाती है।
— डेनिस
5

हास्केल, 72 69 बाइट्स (रेगेक्स नहीं)

g(a:b:c)|a==b=g c
g x=x==[]
any(g.words.concat).mapM(\c->[[c],c:" "])

एक जानवर-बल दृष्टिकोण। Ideone पर इसे आज़माएं ।

ब्लैक बाप को -3 बाइट्स के लिए धन्यवाद।

व्याख्या

सहायक फ़ंक्शन gतार की एक सूची लेता है, और जांचता है कि इसमें समान तार के जोड़े शामिल हैं, जैसे ["aa","aa","bba","bba","ab","ab"]। (अनाम) मुख्य फ़ंक्शन सभी संभावित तरीकों में एक स्ट्रिंग को विभाजित करता है, और जांचता है कि कम से कम एक विभाजन परिणाम एक सूची में है जो gस्वीकार करता है।

g(a:b:c)                                  g on list with elements a, b and tail c,
        |a==b                              in the case that a==b,
             =g c                          recurses to the tail c.
g x=                                      g on any other list x
    x==[]                                  checks that x is empty.
                                           This includes the case where a is not equal
                                           to b, resulting in False.
any(g.words.concat).mapM(\c->[[c],c:" "]) The main function:
                    mapM(\c->[[c],c:" "])  Replace each letter c with either "c" or "c "
                                           in all possible ways, return list of results.
any(              ).                       Check that at least one result satisfies this:
            concat                          Concatenate the 1- or 2-letter strings,
      words.                                split again at each space,
    g.                                      apply g.
— Zgarb
स्रोत
आप के or.mapसाथ बदल सकते हैंany
— BlackCap
@BlackCap बेशक, धन्यवाद! मैं शुरू में था any g.map(words.concat)और सोचा था कि "गोल्फ हे, मैं यह कर सकते हैं anyकरने के लिए or" ...
— Zgarb
5

पायथन 2, 60 बाइट्स

f=lambda s,t='':''<s>f(s[1:],t+s[0])|f(t and s)*f(t)>-(s==t)

मुझे उम्मीद है कि यह सही है। यह बहुत धीमी गति से चलता है और andइष्टतम नहीं दिखता है।

— xsot
स्रोत
1
मैंने स्ट्रिंग्स का उपयोग करने की कोशिश की, लेकिन मैं अपने सूचकांक-आधारित स्कोर के पास कहीं भी नहीं पहुंच सका। वह एक चतुर andतुम्हारे पास है।
— डेनिस
बधाई! विभाजन पर पुनर्विचार करना मेरे मन में छल था।
— xnor
4

जेली , 12 बाइट्स

ŒṖµœs€2ZEµ€S

मेरे अन्य उत्तर की तुलना में दो बाइट्स , लेकिन यह दृष्टिकोण बहुत अधिक कुशल है और सभी लेकिन परीक्षण मामलों में से एक को संभालता है।

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

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

ŒṖµœs€2ZEµ€S  Main link. Argument: s (string)

ŒṖ            Generate all partitions of s.
  µ      µ€   Map the monadic chain between the µ's over the partitions.
   œs€2         Split each string in the partition into two chunks of equal length.
       Z        Zip/transpose, collecting the first halves in one array and the
                second halves in another.
        E       Test the arrays of halves for equality.
           S  Return the sum of the results, counting the number of different
              ways s can be paired.
— डेनिस
स्रोत
3

पायथ - कोई रेगेक्स - 13 12 बाइट्स

जाँच करता है कि क्या कोई भी विभाजन दो में कटा होने पर सभी स्ट्रिंग से बना है जो एक दूसरे के बराबर हैं।

sm.AqMcL2d./

टेस्ट सूट ।

— Maltysen
स्रोत
3

ब्रेकीलॉग , 14 बाइट्स (रेगेक्स नहीं)

lye~l:1j@2zcc?

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

यह परीक्षण के कुछ मामलों के लिए बहुत धीमा है

व्याख्या

ly                  The list [0, …, length(Input)]
  e~l               A list whose length is an element of the previous list
     :1j            Append itself to this list
        @2zc        Split in half, zip and concatenate so that the list contains pairs of
                      consecutive identical elements
            c?      The concatenation of that list must result in the Input
— Fatalize
स्रोत
3

जावास्क्रिप्ट (ईएस 6), कोई रेगेक्सपी, 75 74 बाइट्स

f=s=>!s|[...s].some((_,i)=>i&&s[e='slice'](0,i)==s[e](i,i+=i)&&f(s[e](i)))

रिटर्न 1pairable अन्यथा के लिए 0। संपादित करें: @ edc65 के लिए 1 बाइट का धन्यवाद सहेजा गया।

— नील
स्रोत
अच्छा! substrसंशोधन के बिना एक ही गिनती का उपयोग करना i। लेकिन slice3 बार दोहराए जाने से आप इसे 1 बाइट बचा सकते हैं
— edc65
@ edc65 आपको बिना संशोधन के एक ही गिनती कैसे मिलेगी i? मुझे अहसास है कि s.substr(i,i+i)जैसा है वैसा ही लौटाता है s.slice(i,i+=i)लेकिन बाद में संशोधित मूल्य का उपयोग करता हूं i...
— नील
यह s.substr(i,i)2 बाइट्स कम है, फिर s.slice(i+i)2 बाइट्स अधिक
— edc65
@ edc65 ओह, यह है, मुझे और अधिक कॉफी की आवश्यकता होगी ...
— नील
3

पायथन, 58 बाइट्स

f=lambda s,p='':s>''and(f(p)>-(s==p)<f(s))|f(s[1:],p+s[0])

यह डेनिस की पुनरावर्ती पद्धति पर आधारित है । बूलियन नेगेटिव ट्रिक वहां से भी ली जाती है।

नया विचार (p,s)मूल स्ट्रिंग के विभाजन पर फिर से शुरू करना है ('',s)और sअंतिम चरित्र को बार-बार आगे बढ़ाना है p। यह स्ट्रिंग स्लिंग के बिना सीधे भागों को संदर्भित करने की अनुमति देता है। लेकिन, क्योंकि विभाजन pखाली होने के साथ शुरू होता है, हमें f(s)कॉलिंग के अनंत छोरों से बचने के लिए सावधान रहना चाहिए f(s)।

— XNOR
स्रोत
2

जावास्क्रिप्ट (ईएस 6), 24 बाइट्स

x=>/^((.+)\2)+$/.test(x)

संभवतः इससे कम नहीं मिलता है।

— ETHproductions
स्रोत
ऐसा नहीं होना चाहिए \2?
— नील
@ किसी कारण से, मुझे लगा कि इसके साथ काम किया है \1, लेकिन aabरिटर्न true... फिक्स के लिए धन्यवाद।
— ETHproductions
1

रैकेट 230 बाइट्स

(let((sl string-length)(ss substring))(if(odd?(sl s))(printf ".~n")(begin(let p((s s))(if(equal? s "")(printf "!")
(for((i(range 1(add1(/(sl s)2)))))(when(equal?(ss s 0 i)(ss s i(* 2 i)))(p(ss s(* 2 i)(sl s)))))))(printf ".~n"))))

प्रिंट एक '!' प्रत्येक तरीके के लिए जिसमें स्ट्रिंग दयनीय है। प्रिंट एक '।' अतं मै।

Ungolfed:

(define (f s)
  (let ((sl string-length)                              ; create short names of built-in fns
        (ss substring))
    (if (odd? (sl s))  (printf ".~n")                   ; odd length strings cannot be pairable; end here.
        (begin
          (let loop ((s s))                             ; start testing here
            (if (equal? s "") (printf "!")              ; if no remaining string, it must be pairable
                (for ((i (range 1 (add1 (/(sl s)2)))))  ; ch lengths varying from 1 to half of string length
                  (when (equal? (ss s 0 i)              ; ch if substrings are same
                                (ss s i (* 2 i)))
                    (loop (ss s (* 2 i) (sl s) ))))))   ; if yes, loop to check remaining string.
          (printf ".~n")))))                            ; End of testing.

परिक्षण: 

(println "Following should be pairable")
(f "bbaabbaa")            ; should produce 2 '!' since 2 ways are possible.
(f "aa")
(f "abaaba")
(f "bbababbb")
(f "aabaaababbbaba")
(f "babababa")                    ; should be pairable in 2 ways.
(f "bbbbbbbbbbbb")                ; should be pairable in many ways.
(f "aaababbabbabbbababbaabaabaababaaba")
(f "aaaabaab")
(println "Following should be unpairable")
; (f "a")
(f "ba")
(f "baab")
(f "abaabaaba")
(f "bbbbbbbbbbbbbbb")
(f "baababbabaaaab")
(f "aaaaabbaaaaa")

आउटपुट: 

"Following should be pairable"
!!.
!.
!.
!.
!.
!!.
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!.
!.
!.
"Following should be unpairable"
.
.
.
.
.
.
— rnso
स्रोत
1

पर्ल, 16 +2 = 18 बाइट्स (रेगेक्स के साथ)

-nlझंडे लेकर दौड़े। -Eमुफ्त है।

say/^((.+)\2)+$/

ऐसे दोड़ो:

perl -nlE 'say/^((.+)\2)+$/'

कब्जा समूहों की एक सूची लौटाता है (एक सच्चाई) अगर दानेदार, अशक्त नहीं तो दानेदार।

व्याख्या

-nlझंडे एक पाश में कोड (चलेंगे -n,) (की वजह से हटाया न्यू लाइन में पूर्ण विराम वाले इनपुट डाल -lचर में) $_हर बार, तो कोड हर बार इनपुट दर्ज किया गया है का मूल्यांकन, जब तक कार्यक्रम मैन्युअल समाप्त हो जाता है। -Eझंडा आप कमांड लाइन पर कोड का मूल्यांकन कर सकते हैं, और सक्षम बनाता है sayआदेश।

say/^((.+)\2)+$/

   /^((.+)\2)+$/  #The regex engine
      (.+)\2      #Find any set of at least one character, followed by itself
     (      )+    #Do this at least one time
   /^         $/  #Make sure that this matches the entire string from start to end
say               #Output the result of the regex

यदि कोई मिलान पाया जाता है (जैसे कि स्ट्रिंग खराब होने पर), तो रेगेक्स कैप्चर समूहों की एक सूची लौटाता है, जो एक सत्य का मूल्यांकन करता है, जिसे बाद में पारित किया जाता है say, और आउटपुट। यदि कोई मिलान नहीं पाया जाता है, तो रेगेक्स खाली स्ट्रिंग लौटाता है, जो गलत तरीके से मूल्यांकन करता है, जिसे बाद में पारित किया जाता है say, और आउटपुट।

नमूना:

$ perl -nlE 'say/^((.+)\2)+$/'
aaababbabbabbbababbaabaabaababaaba
baababaababaaba                      #Truthy
baababbabaaaab
                                     #Falsy
bbababbb
bbb                                  #Truthy
aabaaababbbaba
bababa                               #Truthy
abaabaaba
                                     #Falsy
— गेब्रियल बेनामी
स्रोत
1

जीएनयू प्रोलॉग, 49 46 बाइट्स

शायद अन्य वेरिएंट में भी काम करता है, हालांकि वे सभी उसी तरह से तार का प्रतिनिधित्व नहीं करते हैं; जीएनयू प्रोलॉग का प्रतिनिधित्व इस समस्या के लिए एक उपयोगी है।

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

नया संस्करण (कुछ अन्य उत्तरों में देखी गई पुनरावृत्ति चाल का उपयोग करता है):

s(X):-append(A,B,X),(A=B;A\=X,B\=X,s(A),s(B)).

पुराना संस्करण:

s(X):-X=[];append(A,B,X),B\=X,append(C,C,A),s(B).

यह एक विधेय (प्रोलोग के समतुल्य एक कार्य) कहा जाता है s, एक पूर्ण कार्यक्रम नहीं है। इसे इस तरह उपयोग करें:

| ?- s("aa").
true ?
yes
| ?- s("aaababbabbabbbababbaabaabaababaaba").
true ?
yes
| ?- s("baababbabaaaab").
no
| ?- s("bbbbbbbbbbbbbbb").
no

पुराने समाधान की एक दिलचस्प विशेषता यह है कि यदि आप दुभाषिया से पूछते हैं "क्या अधिक समाधान हैं?" के उपयोग के माध्यम ;से true ?शीघ्र, यह रिटर्न "सही" कई बार अलग अलग तरीकों की संख्या स्ट्रिंग व्यक्त किया जा सकता करने के लिए बराबर है (न पूछ की तुलना में, प्रॉम्प्ट पर वापसी दबाने जैसे मैं ऊपर किया के माध्यम से "क्या कोई समाधान है") दिए गए फॉर्म में (जैसे यह दो बार "सही" वापस लौटता है s("aaaa")., क्योंकि इसे (a a)(a a)या इसके रूप में पार्स किया जा सकता है (aa aa))।

प्रोलोग कार्यक्रम अक्सर प्रतिवर्ती होते हैं (दी गई संपत्ति के साथ तार की एक सूची उत्पन्नs करने की अनुमति )। पुराना एक नहीं है (यह एक अनंत लूप में जाता है), लेकिन ऐसा इसलिए है क्योंकि गोल्फ पद्धति के कारण मैं यह सुनिश्चित करता था कि सी नॉनमिप्ट है; यदि आप स्पष्ट रूप से सी को गैर-रिक्त रूप में निर्दिष्ट करने के लिए कार्यक्रम को फिर से लिखते हैं, तो यह "आ", "आब", "आबक" के रूप के तार उत्पन्न करता है, और इसी तरह (प्रोलॉग प्रोलॉग होने के नाते, यह उन पात्रों के लिए पहचान निर्दिष्ट नहीं करता है जो उन्हें बनाते हैं। ऊपर, सिर्फ एक विनिर्देश जो वर्ण समान हैं)। नया रूप "आ", "आबब", "अब्बाज" और इसी तरह के तार उत्पन्न करता है; यह अपने आप में एक अनन्त लूप है, और इस तरह कभी भी उस बिंदु को हिट नहीं करता है जिस पर यह शून्य-लंबाई वाली स्ट्रिंग का पता लगाने में विफल होने के कारण फंस जाएगा।

1

ब्रेनफक, 177 बाइट्स

+[<<<<,]>>>>[>+[>+[[>>]<+<[<<]>+>-]<[>+<-]>>>,>>[>>]+<<[<+>>-<-]<[>+<-]>>[,>[-<<
<<]<[<<<<]>]<[[<<]>]>>]>>[[>+>>>]>>>[>]<<<<[>+[-<<<,<]<[<<<[[<<<<]>>]<]>]>>]<[[-
>>>>]>>[<]<]<<]<.

प्रारूपित:

+[<<<<,]
>>>>
[
  >+
  [
    >+
    [
      [>>]
      <+<[<<]
      >+>-
    ]
    <[>+<-]>
    >>,>>[>>]
    +<<[<+> >-<-]
    <[>+<-]>
    >
    [
      not equal
      ,>[-<<<<]
      <[<<<<]
      >
    ]
    <
    [
      equal
      [<<]
      >
    ]
    >>
  ]
  >>
  [
    mismatch
    [>+>>>]
    >>>[>]
    <<<<
    [
      backtrack
      >+[-<<<,<]
      <
      [
        not done yet
        <<<
        [
          [<<<<]
          >>
        ]
        <
      ]
      >
    ]
    >>
  ]
  <
  [
    match
    [->>>>]
    >>[<]
    <
  ]
  <<
]
<.

एक अनुगामी न्यूलाइन के बिना इनपुट की अपेक्षा करता है। \x00झूठे के लिए और \x01सच के लिए प्रिंट ।

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

यह गहराई-पहली खोज को लागू करता है। विशेष रूप से: वर्तमान प्रत्यय से शुरू होने वाली बढ़ती लंबाई के बार-बार उपसर्गों के लिए जांच करें, फिर एक मैच पाए जाने पर अगले प्रत्यय पर जाएं, अन्यथा पीछे।

शुरुआत में, स्ट्रिंग को उलट दिया जाता है और एक प्रहरी \x01अंत में रखा जाता है।

टेप को 4-सेल नोड्स में विभाजित किया गया है। एक नोड का मेमोरी लेआउट है:

c h x 0

cचरित्र कहां है, इस hबात के लिए एक ध्वज है कि क्या चरित्र दोहराए गए उपसर्ग के पहले छमाही में है, और xवर्तमान जोड़े की तुलना किए जा रहे वर्णों पर नज़र रखने के लिए एक ध्वज है। hजबकि झंडे जगह में रहने के xझंडे एक चलती खिड़की के रूप में।

यदि स्ट्रिंग दयनीय है, तो मुख्य लूप के अंत में प्रहरी के पास सूचक भूमि; अन्यथा, सूचक बैकट्रैकिंग करते समय स्ट्रिंग के बाईं ओर गिर जाता है।

— मिच श्वार्ट्ज
स्रोत
1

ब्रेकीलॉग , 5 बाइट्स

~c~jᵐ

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

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

व्याख्या

~c     Reversed concatenate: find a list that, when concatenated, results in the input string
       This examines all partitions of the input
  ~jᵐ  Map reversed juxtapose: for each string in that list, is it the result of concatenating
       a string to itself?

जैसे इनपुट स्ट्रिंग के लिए "ababcc", ~cअलग-अलग विभाजन की कोशिश करता है जब तक कि वह नहीं आता है ["abab", "cc"], जिस बिंदु पर ~jसूची, ᵐआउटपुट ["ab", "c"], और विधेय दोनों के लिए आइटम सफल होता है।

— DLosc
स्रोत
1

आर , 31 बाइट्स

grepl("^((.+)\\2)+$",scan(,""))

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

रेटिना जवाब के आधार पर।

आर , 129 बाइट्स

और यहाँ एक मूल, गैर-रेगेक्स उत्तर है:

o=(y=utf8ToInt(scan(,"")))<0;for(i in 2*1:(sum(y>0)/2))for(j in 1:(i/2)){w=i:(i-j+1);v=w-j;if(all(y[w]==y[v]))o[c(v,w)]=T};all(o)

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

— निक केनेडी
स्रोत
0

लिथ , 57 वर्ण

#S::((? (!= (null) (match S "^((.+)\\2)+$")) true false))

नमूना उपयोग:

% pairable_strings.lithp
(
    (def f #S::((? (!= (null) (match S "^((.+)\\2)+$")) true false)))
    (print (f "aa"))
    (print (f "aabaaababbbaba"))
    (print (f "aaababbabbabbbababbaabaabaababaaba"))
    (print (f "ba"))
)

# ./run.js pairable_strings.lithp
AtomValue { value: 2, type: 'Atom', name: 'true' }
AtomValue { value: 2, type: 'Atom', name: 'true' }
AtomValue { value: 2, type: 'Atom', name: 'true' }
AtomValue { value: 3, type: 'Atom', name: 'false' }
— Andrakis
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.