Eine Zeichenfolge kann gepaart werden, wenn sie in Unterzeichenfolgen unterteilt werden kann, von denen jede eine Zeichenfolge ist, die zweimal nacheinander wiederholt wird. Zum Beispiel kann aabaaababbbabagepaart werden als:

aaba aaba
b b
ba ba

Bei einer nicht leeren Zeichenfolge aus a's und b' s wird ein Wahrheitswert ausgegeben, falls dies paarweise möglich ist, und ein Falsey-Wert, falls dies nicht der Fall ist.

Pairable:

aa
abaaba
bbababbb
aabaaababbbaba
babababa
bbbbbbbbbbbb
aaababbabbabbbababbaabaabaababaaba
aaaabaab

Nicht paarbar:

a
ba
baab
abaabaaba
bbbbbbbbbbbbbbb
baababbabaaaab
aaaaabbaaaaa

Ich ermutige Sie, nicht auf Regex basierende Lösungen zu entwickeln, auch wenn es in Ihrer Sprache bereits eine kürzere Regex-Antwort gibt. Sie können sie als "kein regulärer Ausdruck" markieren. Mit Regex meine ich ein integriertes Subsystem für die Suche nach Zeichenfolgenmustern.

Bestenliste:

var QUESTION_ID=98252,OVERRIDE_USER=20260;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/98252/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Python 2, 68 63 Bytes

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

Gibt True oder False zurück . Teste es auf Ideone .

Retina , 11 Bytes

^((.+)\2)+$

Probieren Sie alle Testfälle aus. Die ersten zwei Bytes machen es mehrzeilig.

Ziemlich wörtliche Interpretation der Regeln, verwendet offensichtlich Regex, wie alle Retina-Programme.

Gelee , 10 Bytes

ẆŒPẋ€€2F€ċ

Nicht gerade effizient ... Probieren Sie es online!

Wie es funktioniert

ẆŒ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.

Haskell, 72 bis 69 Bytes (kein regulärer Ausdruck)

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

Ein Brute-Force-Ansatz. Probieren Sie es auf Ideone .

Danke an BlackCap für -3 Bytes.

Erläuterung

Die Hilfsfunktion erstellt geine Liste von Zeichenfolgen und prüft, ob sie aus Paaren identischer Zeichenfolgen besteht, z ["aa","aa","bba","bba","ab","ab"]. Die (anonyme) Hauptfunktion teilt einen String auf alle möglichen Arten und überprüft, ob mindestens eine Aufteilung zu einer Liste führt, die gakzeptiert.

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.

Python 2, 60 Bytes

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

Ich hoffe das ist richtig. Es läuft ziemlich langsam und das andsieht nicht optimal aus.

Gelee , 12 Bytes

ŒṖµœs€2ZEµ€S

Zwei Bytes länger als meine andere Antwort , aber dieser Ansatz ist viel effizienter und behandelt alle Testfälle bis auf einen.

Probieren Sie es online!

Wie es funktioniert

ŒṖµœ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.

Pyth - Kein Regex - 13 12 Bytes

Überprüft, ob eine der Partitionen aus allen Zeichenfolgen besteht, die einander entsprechen, wenn sie in zwei Teile geteilt werden.

sm.AqMcL2d./

Test Suite .

Brachylog , 14 Bytes (kein regulärer Ausdruck)

lye~l:1j@2zcc?

Probieren Sie es online!

Dies ist für einige Testfälle zu langsam

Erläuterung

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

JavaScript (ES6), kein regulärer Ausdruck, 75 bis 74 Byte

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

Returns 1für paarbar anders 0. Bearbeiten: 1 Byte dank @ edc65 gespeichert.

Python, 58 Bytes

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

Dies basiert auf der rekursiven Methode von Dennis . Der Boolesche Negationstrick wird auch von dort übernommen.

Die neue Idee besteht darin, Partitionen (p,s)der ursprünglichen Zeichenfolge zu ('',s)wiederholen, indem das erste Zeichen von sals letztes Zeichen von beginnend wiederholt verschoben wird p. Auf diese Weise können die Teile direkt referenziert werden, ohne dass ein Aufschneiden der Zeichenfolgen erforderlich ist. Aber, da die Partition mit beginnt pleer, müssen wir vorsichtig sein , um Endlosschleifen von zu vermeiden f(s)Berufung f(s).

JavaScript (ES6), 24 Byte

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

Wird wahrscheinlich nicht kürzer.

PHP, 40 Bytes

gibt 0 für falsch und 1 für wahr aus

<?=preg_match("#^((.+)\\2)+$#",$argv[1]);

Python, 66 64 Bytes

Danke @Zgarb für -1 Byte!

f=lambda x,s=1:x>x[:s]and(x==2*x[:s])|f(x[:s])&f(x[s:])|f(x,s+1)

Rückgabe Trueoder False.

Probieren Sie es online!

Jede Hilfe beim Golfspielen wäre willkommen.

Schläger 230 Bytes

(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"))))

Druckt ein '!' für jede Art und Weise, in der die Zeichenfolge paarbar ist. Druckt ein '.' Am Ende.

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.

Testen:

(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")

Ausgabe:

"Following should be pairable"
!!.
!.
!.
!.
!.
!!.
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!.
!.
!.
"Following should be unpairable"
.
.
.
.
.
.

Perl, 16 +2 = 18 Bytes (mit Regex)

Laufen Sie mit den -nlFahnen. -Eist gratis.

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

Rennen wie:

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

Gibt eine Liste der Capture-Gruppen (eine Wahrheit) zurück, wenn sie paarbar sind, und eine Nullzeichenfolge, wenn sie nicht paarbar ist.

Erläuterung

Die -nlFlags führen den Code in einer Schleife ( -n) aus, wobei die Eingabe (mit wegen entferntem Zeilenumbruch -l) $_jedes Mal in die Variable eingefügt und der Code bei jeder Eingabe ausgewertet wird, bis das Programm manuell beendet wird. Mit dem -EFlag können Sie Code in der Befehlszeile auswerten und den sayBefehl aktivieren.

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

Wenn eine Übereinstimmung gefunden wird (z. B. wenn die Zeichenfolge gepaart werden kann), gibt der Regex eine Liste der Erfassungsgruppen zurück, die zu einer Wahrheit ausgewertet wird, die dann an übergeben sayund ausgegeben wird. Wenn keine Übereinstimmung gefunden wird, gibt der reguläre Ausdruck die leere Zeichenfolge zurück, die als falsch ausgewertet wird, die dann an übergeben sayund ausgegeben wird.

Probe:

$ perl -nlE 'say/^((.+)\2)+$/'
aaababbabbabbbababbaabaabaababaaba
baababaababaaba                      #Truthy
baababbabaaaab
                                     #Falsy
bbababbb
bbb                                  #Truthy
aabaaababbbaba
bababa                               #Truthy
abaabaaba
                                     #Falsy

GNU Prolog, 49 46 Bytes

Funktioniert wahrscheinlich auch in anderen Varianten, obwohl sie nicht alle Zeichenfolgen auf die gleiche Weise darstellen. Die Darstellung von GNU Prolog ist für dieses Problem nützlich.

Es ist unklar, ob dies als Verwendung von Regex gilt oder nicht. Es werden keine regulären Ausdrücke verwendet, aber die gesamte Semantik der Sprache ähnelt der von regulären Ausdrücken.

Neue Version (verwendet den Rekursionstrick, der in einigen anderen Antworten zu sehen ist):

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

Ältere Version:

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

Dies ist ein aufgerufenes Prädikat (Prolog-Äquivalent einer Funktion) s, kein vollständiges Programm. Benutze es so:

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

Ein interessantes Merkmal der älteren Lösung ist, dass wenn Sie den Interpreter fragen, "gibt es mehr Lösungen?" Bei Verwendung von ;an der true ?Eingabeaufforderung (anstatt zu fragen, ob "Gibt es eine Lösung?", bei Drücken der Eingabetaste an der Eingabeaufforderung, wie oben beschrieben) wird so oft "true" zurückgegeben, wie die Zeichenfolge auf verschiedene Arten ausgedrückt werden kann in der angegebenen Form (zB gibt es mit "true" zweimal zurück s("aaaa")., da dies als (a a)(a a)oder als geparst werden kann)(aa aa) ).

Prolog - Programme sind oft reversibel (so dass generieren eine Liste von Strings mit der angegebenen Eigenschaft). Das ältere ist es nicht (es geht in eine Endlosschleife), aber das liegt an der Golfmethode, die ich verwendet habe, um sicherzustellen, dass C nicht leer ist; Wenn Sie das Programm so umschreiben, dass C explizit als nicht leer angegeben wird, werden Zeichenfolgen der Form "aa", "aabb", "aabbcc" usw. generiert bis, nur eine Angabe, welche Zeichen gleich sind). Das neuere erzeugt Zeichenketten der Form "aa", "abab", "abcabc" und so weiter; Dies ist eine Endlosschleife für sich und trifft daher nie den Punkt, an dem sie hängen bleiben würde, weil eine Zeichenfolge mit der Länge Null nicht erkannt wird.s

Brainfuck, 177 Bytes

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

Formatiert:

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

Erwartet Eingaben ohne abschließende Zeilenumbrüche. Druckt \x00für falsch und\x01 für wahr.

Probieren Sie es online aus.

Dies implementiert die Tiefensuche. Insbesondere: Überprüfen Sie ab dem aktuellen Suffix, ob wiederholte Präfixe mit zunehmender Länge vorhanden sind, und wechseln Sie dann zum nächsten Suffix, wenn eine Übereinstimmung gefunden wird.

Zu Beginn ist die Zeichenfolge umgekehrt und ein Sentinel \x01 am Ende platziert.

Das Band ist in 4-Zellen-Knoten unterteilt. Das Speicherlayout eines Knotens ist:

c h x 0

Dabei chandelt es sich hum ein Flag, das angibt, ob sich das Zeichen in der ersten Hälfte eines wiederholten Präfixes befindet, und xum ein Flag, mit dem das aktuelle Zeichenpaar verfolgt wird, das verglichen wird. Die hFahnen bleiben an Ort und Stelle, während die xFahnen ein sich bewegendes Fenster bilden.

Wenn die Zeichenfolge gepaart werden kann, landet der Zeiger neben dem Sentinel am Ende der Hauptschleife. Andernfalls fällt der Zeiger beim Zurückverfolgen von der linken Seite der Zeichenfolge ab.

Brachylog , 5 Bytes

~c~jᵐ

Probieren Sie es online!

Beachten Sie, dass dieser Algorithmus sehr lange dauern kann , insbesondere in Falsey-Fällen, da er jede mögliche Partition der Eingabezeichenfolge überprüft.

Erläuterung

~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?

Versucht für eine Eingabezeichenfolge wie "ababcc", ~cverschiedene Partitionen, bis es zu kommt ["abab", "cc"], an welchem ​​Punkt ~jerfolgreich für beide Elemente der Liste, ᵐAusgaben ["ab", "c"]und das Prädikat erfolgreich ist.

R , 31 Bytes

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

Probieren Sie es online!

Basierend auf der Retina-Antwort.

R , 129 Bytes

Und hier ist eine originelle, nicht reguläre Antwort:

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)

Probieren Sie es online!

Lithp , 57 Zeichen

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

Beispielnutzung:

% 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' }