Рядок є дозволеним, якщо його можна розділити на підрядки, кожен з яких є рядком, повтореним двічі поспіль. Наприклад, aabaaababbbabaдобовий як:

aaba aaba
b b
ba ba

Враховуючи не порожній рядок a's and b' s, виведіть значення Truthy, якщо воно є добовим, і значення Falsey, якщо це не так.

Добові:

aa
abaaba
bbababbb
aabaaababbbaba
babababa
bbbbbbbbbbbb
aaababbabbabbbababbaabaabaababaaba
aaaabaab

Не дозволено:

a
ba
baab
abaabaaba
bbbbbbbbbbbbbbb
baababbabaaaab
aaaaabbaaaaa

Я закликаю вас придумати рішення, що не ґрунтуються на регулярних виразках, навіть коли на вашій мові вже є коротша відповідь. Ви можете позначити їх як "без регулярного вираження". Під регулярним виразом я маю на увазі вбудовану підсистему узгодження рядка.

Табло:

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 байт

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

Повертає істинне чи помилкове . Перевірте це на Ideone .

Сітківка , 11 байт

^((.+)\2)+$

Спробуйте всі тестові випадки. Перші два байти роблять його багаторядковим.

Досить буквальне тлумачення правил, очевидно, використовує регулярний вираз, як і всі програми Retina.

Желе , 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.

Haskell, 72 69 байт (без регулярного вираження)

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

Підхід грубої сили. Спробуйте це на Ideone .

Завдяки BlackCap за -3 байти.

Пояснення

Функція helper 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.

Python 2, 60 байт

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

Я сподіваюся, що це правильно. Він працює досить повільно і andне виглядає оптимально.

Желе , 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.

Pyth - No Regex - 13 12 байт

Перевіряє, чи будь-який з розділів складається з усіх рядків, які дорівнюють один одному, коли вони розбиваються на два.

sm.AqMcL2d./

Тестовий сюїт .

Брахілог , 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

JavaScript (ES6), відсутність регулярного вираження, 75 74 байт

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

Повертається 1за можливим інакше 0. Редагувати: Збережено 1 байт завдяки @ edc65.

Пітон, 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).

JavaScript (ES6), 24 байти

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

Напевно, не коротше цього.

PHP, 40 байт

друкує 0 для помилкових та 1 для істинних

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

Пітон, 66 64 байт

Дякую @Zgarb за -1 байт!

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

Повертається Trueабо False.

Спробуйте в Інтернеті!

Будь-яка допомога в гольфі це буде вдячно.

Ракетка 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"))))

Друкує "!" для кожного способу, в якому рядок є добовим. Друкує "." в кінці.

Безголівки:

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

Perl, 16 +2 = 18 байт (з регулярним виразом)

Біжи з -nlпрапорами. -Eє безкоштовним.

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

Виконувати як:

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

Повертає список груп захоплення (truthy), якщо невірно, нульовий рядок, якщо не паверує.

Пояснення

Ці -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

GNU Prolog, 49 46 байт

Напевно, працює і в інших варіантах, хоча вони не представляють рядки однаково; Представлення GNU Prolog є корисним для цієї проблеми.

Незрозуміло, чи вважається це використанням регулярного вираження чи ні. Тут не використовується жодна функція, що нагадує регулярні виразки, але вся семантика мови схожа з такою у регулярного вираження.

Нова версія (використовує хитрість рекурсії, яку бачите в деяких інших відповідях):

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).

Це предикат (еквівалент функції Prolog), який називається s, а не повна програма. Використовуйте його так:

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

Цікава особливість старого рішення полягає в тому, що якщо ви запитаєте перекладача, "чи більше рішень?" через використання ;в тій true ?рядку (а не питати «є якесь - яке рішення» з допомогою натискання повернення в командному рядку, як я зробив вище), вона повертає «істини» число раз , дорівнює кількості різних способів рядки може бути виражена у даній формі (наприклад, він повертає "true" двічі s("aaaa")., оскільки це може бути проаналізовано як (a a)(a a)або як (aa aa)).

Програми Prolog часто оборотна ( що дозволяє , sщоб сформувати список рядків із заданою властивістю). Старший - це не (він переходить у нескінченний цикл), але це через метод гольфу, який я використовував, щоб переконатися, що C не порожній; якщо ви перезаписуєте програму, щоб явно вказати C як порожній, вона генерує рядки форми "aa", "aabb", "aabbcc" і так далі (Prolog, будучи Prolog, не визначає ідентичності символів, які їх складають вгору, лише уточнення, які символи однакові). Новіший генерує рядки форми "aa", "abab", "abcabc" тощо; це сам по собі нескінченний цикл, і тому ніколи не потрапляє в точку, в якій він застрягне через невдачу виявити рядок нульової довжини.

Brainfuck, 177 байт

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

Відформатовано:

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

Очікує введення без зворотного нового рядка. Друкується \x00за помилкові та \x01правдиві.

Спробуйте в Інтернеті.

Це реалізує перший поглиблений пошук. Зокрема: перевірте наявність повторних префіксів збільшення довжини, починаючи з поточного суфіксу, а потім перейдіть до наступного суфікса, якщо знайдено збіг, інакше зворотний шлях.

На початку рядок обернено і \x01на кінці розміщено дозорну .

Стрічка ділиться на 4-клітинні вузли. Макет вузла пам'яті:

c h x 0

де cсимвол, hє прапором того, чи є символ у першій половині повторного префікса, і xє прапором для відстеження поточної пари символів, що порівнюються. В hпрапори залишаються на місці в той час як xпрапори утворюють вікно рухається.

Якщо рядок є добовим, вказівник розташовується поруч із дозорною в кінці основного циклу; в іншому випадку вказівник падає з лівого боку рядка під час зворотного відстеження.

Брахілог , 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"], і предикат завершується успішно.

R , 31 байт

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

Спробуйте в Інтернеті!

На основі відповіді Retina.

R , 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)

Спробуйте в Інтернеті!

Літп , 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' }