Будемо мати функцію яка займає рядок і видаляє всі пари суміжних однакових символів. Наприклад$f$

$f(a\color{red}{bb}ba\color{red}{cc}) = aba$

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

Ми будемо називати рядок ідеально парним, якщо повторне застосування в кінцевому підсумку дасть порожній рядок. Наприклад, рядок вище не є ідеально парним, тому що якщо ми знову застосуємо ми все одно отримаємо . Однак такий рядок, як є ідеально парним, тому що якщо застосувати тричі, ми отримаємо порожню рядокf a b a e a b b c c a d d e $abbbacc$$f$$aba$$eabbccadde$$f$

$f(ea\color{red}{bbcc}a\color{red}{dd}e) = eaae$

$f(e\color{red}{aa}e) = ee$

$f(\color{red}{ee}) =$

Ваше завдання - написати ідеально парний комп'ютерний код, який займає рядок (для друку ASCII) і вирішує, чи він ідеально спарений. Перевірка вашого джерела повинна бути самою ідеально парною рядком , хоча ваш код не обов'язково повинен обмежуватися ASCII для друку.

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

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

Випробування

$abbbacc \rightarrow \mathrm{False}\\ abcba \rightarrow \mathrm{False}\\ abab \rightarrow \mathrm{False}\\ abbbaabacc \rightarrow \mathrm{True}\\ eabbccadde \rightarrow \mathrm{True}\\ bbbb \rightarrow \mathrm{True}$

Haskell, 146 124 байт

((""##))
a===bb=bb==a
((aa:bb))##((cc:dd))|aa===cc=bb##dd|1==1=((cc:aa:bb))##dd
a##""=""===a
""##cc=((cc!!00:cc!!00:""))##cc

Без коментарів. Повертає Trueабо False.

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

Редагувати: -22 байти завдяки майстру @Cat

Python 2 , 94 байти

ss=''

for cc in input():ss=[cc+ss,ss[1:]][cc==ss[:1]]

print''==ss##tnirp[,+[=:)(tupni nirof=

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

Весь крок оновлення ss=[cc+ss,ss[1:]][cc==ss[:1]]скасовується на просто =[+,[.

05AB1E , 26 24 22 20 18 байт

-2 байти завдяки ов . Виводить 0, якщо рядок ідеально спарений, 1 - інакше.

ΔγʒgÉ}JJ}ĀqqĀÉgʒγΔ

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

ΔγʒgÉ} JJ} ĀqqĀÉgʒγΔ - Повна програма.
Δ} - поки результат більше не зміниться:
 γʒ} - Розбийте рядок на шматки рівних символів і відфільтруйте:
   gÉ - Чи непарна довжина?
      JJ - А після фільтрування з'єднайте деталі разом, але зробіть це
                     двічі, щоб зберегти 2 байти, як у попередніх версіях.
         Ā - Перевірте, чи результат порожній
          q - припинити (припинити) виконання. Решта коду ігнорується.
           qĀÉgʒγΔ - відобразить невідповідну частину, щоб допомогти у розташуванні джерела.

Попередні версії

Ця суто покладається на невизначену поведінку (тому немає "мертвого коду"), і виводить [['0']] для ідеально парних рядків і [['1']] для не ідеально збіганих рядків:

ΔγεDgÉ£}JJ}ĀĀ£ÉgDεγΔ 

І 22-байтова версія, пояснила, що якраз вище, але не зловживає UB і дає здорові значення.

ΔγεDgÉ£}JJ}ĀqqĀ£ÉgDεγΔ – Full program.
Δ         }            – Until fixed point is reached (starting from the input value):
 γε    }                 – Group equal adjacent values, and for each chunk,
   DgÉ                     – Duplicate, get its length mod by 2.
      £                    – And get the first ^ characters of it. This yields the
                             first char of the chunk or "" respectively for odd-length
                             and even-length chunks respectively.
         JJ                – Join the result to a string, but do this twice to help
                             us with the source layout, saving 2 bytes.
            Ā           – Check if the result is an empty string.
             q          – Terminate the execution. Any other commands are ignored.
              qĀ£ÉgDεγΔ – Mirror the part of the program that isn't otherwise removed
                          anyways. This part forgoes }JJ} because that substring will
                          always be trimmed by the algorithm anyway.

Cubix , 54 байти

U#;!u1@.Oi>??>i..??O.@1^^...u--u.u!ww;..#..U..;..;!^^!

Нічого не виводиться, якщо рядок є ідеально парним і в 1іншому випадку.
Спробуйте тут

Кубіфікований

      U # ;
      ! u 1
      @ . O
i > ? ? > i . . ? ? O .
@ 1 ^ ^ . . . u - - u .
u ! w w ; . . # . . U .
      . ; .
      . ; !
      ^ ^ !

Пояснення

Більшість символів - це наповнювач, необхідний для ідеального сполучення коду. Замінивши тих, на кого .немає (op), ми отримаємо

      U # ;
      ! u 1
      @ . O
i . ? . > i . . ? . . .
. . ^ . . . . u - . . .
. . . w ; . . . . . . .
      . ; .
      . ; !
      ^ ^ !

Це можна розділити на три етапи:

• Перевірте, чи не стоїть порожній рядок (зліва iта зліва ?).
• Цикл, кидаючи символи на стек і вискакуючи дублікати (все внизу та праворуч).
• Перевірте, чи стопка порожня (матеріал у верхній частині).

V , 20 , 18 байт

òóˆ±òø‚

::‚øò±ˆóò

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

Hexdump:

00000000: f2f3 88b1 f2f8 820a 0a3a 3a82 f8f2 b188  .........::.....
00000010: f3f2                                     ..                   ....

Виходи 0 для тритух, 1 для помилки. Завдяки nmjcman101 за непряме збереження 2 байтів.

ò        ò        " Recursively...
 ó                "   Remove...
  <0x88>          "     Any printable ASCII character
        ±         "     Followed by itself
          ø       " Count...
           <0x82> "   The number of non-empty strings

::<0x82>øò±<0x88>óò      " NOP to ensure that the code is paired

R , 142 126 байт

Жорсткіша логіка і деякі коментарі байтів, які гольфував @Giuseppe

f=function(x,p="(.)\\1")"if"(grepl(p,x),f(sub(p,"",x)),!nchar(x))##x(rahcn!,x,,p(bus(f,)x,p(lperg("fi")"1\\).("=p,x(noitcnuf=f

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

f=function(x,p="(.)\\1")"if"(nchar(x),"if"(grepl(p,x),f(sub(p,"",x)),0),1)##)1,)0,xp(bus(f,)x,p(lperg("fi",)x(rahcn("fi")"1).("=p,x(noitcnuf=f

Оригінал:

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

Рекурсивна функція детектора з подальшим коментуванням усіх символів функції у зворотному порядку.

APL (Dyalog) , 38 байт

''≡{'(.)\1'⎕R''⊢⍵}⍣≡⍝⍝≡⍣}⍵⊢R⎕'1\).('{≡

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

Сітківка , 28 26 байт

+`(.)\1

C`^$

$^`C1\).(`+

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

Виходи `C1\).(`+0`C1\).(`+для `C1\).(`+1`C1\).(`+фальшивих і для справжніх справ.

Мозок-Флак , 228 200 байт

(()){{{}([]<<{{(({}<<>>)<<>>[({})]){{{{}(<<<<>>()>>)((<<>>))}}}{}{}<<>>{}<<>>}}{}<<>>>>[[]])}}{}(<<({{(())(<<()>>)}}<<>>)>>){{{{}{}}((){{}{}{}{}{}}(()())())[[]((){{}{}}())[]]((){{}{}}[[][]]()){{}{}}}}

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

Це трохи докази концепції. Можливо, це може бути і коротшим. Однак він не використовує коментарів.

Виходи, 0,0якщо вхід ідеально парний і 0,1якщо вхід ні.

sed 4.2.2 , 34 байт

:;:t;ss((..??\??))\1ss1;t;/..??/cc

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

Парні рядки дають порожній вихід, непарні - дають ct:

Тривіальна паліндромна версія має 32 роки :;ss(.)\1ss;t;/./cc/./;t;1\).(;:. Старе рішення було :;ss((..??\??))\1ss1;t;;/./cc/./t:(змінено, оскільки поточне зловживають cменше, редагуйте: так, тепер залишився лише 1 символ c: D)

(зауважте, що ;це роздільник операторів)

: оголошує порожню мітку

:t оголошує етикетку t

ss((..??\??))\1ss1це заміна, в sed ви можете змінити роздільник на заміну, і це те, що я зробив, змінивши його на s, так що це робиться - це замінити перше (як позначається 1в кінці)

• відповідність ((..??\??))\1

  • . будь-який персонаж
  • .?? з подальшим необов'язковим символом
  • \?? і необов'язковий ?
  • за ним слідує те саме, що поруч

• ні з чим

Тепер ця заміна поєднується з собою, тому ;до і після її скасування теж буде скасовано

t і поверніть до мітки, поки не буде більш успішних підстановок

/..?/якщо .(підстановочний знак) .?з додатковим символом збігається

• cc змінити буфер на c

Мозг-Флак , 112 110 108 байт

(()){{}({<<(({}<<>>)<<>>[({})]){{((<<>>)<<>>)}}{}{##{

}<<>>>>{}<<>>}<<>>)}{}((){{<<>>[[]]}})##}{}])}{([)}(}

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

Це ґрунтується на моїй відповіді з відповідності дужок? .

Намагався не користуватися коментарями, але застряг, намагаючись змусити поп-ніладів ( {}) пари. Проблема полягає в найпростішому способі з’єднати пару дужок - оточити її в іншій парі такого ж типу. Хоча це легко для інших ниладів, {...}монада створює петлі. Щоб вийти з циклу, вам потрібно натиснути 0, але як тільки ви вийдете з циклу, вам доведеться спливати 0, що ускладнює проблему.

66-байтне попереднє парне рішення:

(()){{}({<(({}<>)<>[({})]){((<>)<>)}{}{}<>>{}<>}<>)}{}((){<>[[]]})

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

Виходи 1або 1,0якщо вхід - це ідеальне сполучення, 0,0якщо ні.

Без коментарної версії, 156 байт

(()){{{}({<<(({}<<>>)<<>>[({{}((<<[[]]>>)){}}{}(<<[]>>){{}{}}{})]){{((<<>>)<<>>)}}{{}{}{}}{}{}<<>>>>{}<<>>}<<>>)}}{{}{}}{}((){<<>>[[]]})(<<()()>>){{}{}{}}{}

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

Як зазначив Cat Wizard, перша відповідь працює не для всіх перекладачів, так як не всі звертаються з #коментарями. Ця версія не містить коментарів.

Japt, 24 22 байти

Вихідні дані falseдля truthy та truefor falsey.

&&!!e"(.)%1"PP"1%).("e

Спробуй це

Мозок-Флак , 96 байт

{<<>>(({})<<>>[(([{}<<>>]))]){((<<[[]]>>))}{}{}{}{}<<>>}<<>>{{{}{}{}{}{}}((<<>>){{}{}}){{{}}}}{}

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

Нічого не виводиться, якщо вхід ідеально парний, 0інакше.

Не ідеально поєднана (оригінальна) версія:

{<>(({})<>[({}<>)]){((<()>))}{}{}{}<>}<>{((<>))}{}

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

Haskell , 66 байт

null.foldr((%))"";;cc%((r:t))|cc==r=t;;t%s=t:s--s:t=s%=r|t:dlof.un

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

Cat Wizard врятував 6 байт.

Додайте ++ , 146 байт

D,g,@~~,L2_|*;;*|_2L,@,g,D
D,ff,@^^,BG€gBF;;FBg€GB,@D1:?:

xx:?

aa:1
`bb
Bxx;;B
Waa*bb,`yy,$ff>xx,`aa,xx|yy,`bb,Byy,xx:yy

O;;O:,B,`,|,`,>$,`,*W`

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

Веселий факт: Це було 272 байти задовго до того, як було розпочато пояснення, тепер він перемагає Java.

Виходи Trueдля ідеально збалансованих рядків та в Falseіншому випадку

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

NB : Помилка з BFкомандами була виправлена під час розробки цієї відповіді.

Як це працює

$\mathit{ff}$$g$$\mathit{ff}$$\mathit{ff}$$g$$S$$\mathit{ff}(S)$$S$

$S$$abbbaabacc$$[[a], [bbb], [aa], [b], [a], [cc]]$$g$, і замініть підлісти на результат функції.

$g$$2$$x$$[a]$$[bb]$$[ccc]$

$x$$x > 2$$x - 2$$x$*

$g(s)$$s$BF^D,ff,@^^,$g$$r$$r$;;

$\mathit{ff}$$g$$\mathit{ff}$

• $\mathit{xx}$$\mathit{ff}$
• $\mathit{yy}$$\mathit{ff}$
• $\mathit{aa}$
• $\mathit{bb}$$\mathit{yy}$

$g$$\mathit{xyab}$$g$

€$\mathit{abc}${...}$g${...}$\mathit{gg}$$\mathit{ff}$$g$

D,gg,@~~,L2_|*;;*|_2L,@D             (NB: -2 bytes)
D,ff,@^^,BG€{gg}BF;;FB}gg{€GB,@D?:   (NB: +6 bytes)

що на 4 байти довше.

$x = 5$$x = 15$

x+10 ; Explicit argument
+10  ; Implicit argument, as x is active

$x$`

$\mathit{ff}$$g$$\mathit{xx}$xx:?$\mathit{xx}$$\mathit{aa}$aa:1$1$$\mathit{xx}$$\mathit{bb}$

`bb
Bxx

$\mathit{bb}$$\mathit{xx}$$\mathit{aa} := 1$$\mathit{bb} := \neg \neg \mathit{xx}$

Потім вводимо наш цикл while:

Waa*bb,`yy,$ff>xx,`aa,xx|yy,`bb,Byy,xx:yy

Цикл while - це конструкція в Add ++: вона працює безпосередньо над кодом, а не змінними. Конструкти приймають серію кодових висловлювань, розділених з ,якими вони працюють. Хоча і якщо оператори також приймають умову безпосередньо перед першою, ,яка складається з одного дійсного оператора, такого як команда інфіксації зі змінними. Варто зазначити одне: активну змінну не можна опустити з умови.

aa*bb$\mathit{aa}$$\mathit{bb}$$\mathit{yy}$$\mathit{ff}(x)$

`yy,$ff>xx

$\mathit{aa}$

• 1) Нове значення не відповідає старому значенню (цикл, поки унікальний)
• 2) Нове значення не є порожнім рядком

Одним з найбільших недоліків Add ++ є відсутність складених операторів, що зумовлює необхідність наявності другої змінної циклу. Ми присвоюємо наші дві змінні:

З кодом

`aa,xx|yy,`bb,Byy

|B $\mathit{xx}$$\mathit{yy}$xx:yy

$\mathit{ff}$$\mathit{aa}$$\mathit{bb}$

$\mathit{aa}$$\mathit{x} = \mathit{y}$$\mathit{aa}$$\mathit{yy}$$\mathit{bb}$$\mathit{aa}$

Тоді ми доходимо до остаточного твердження:

O

$\mathit{bb}$

• $\mathit{aa} = 1$$\mathit{bb} = \mathrm{False}$$\mathrm{False}$
• $\mathit{aa} = \mathrm{True}$$\mathit{bb} = \mathrm{False}$$\mathrm{False}$
• $\mathit{aa} = \mathrm{False}$$\mathit{bb} = \mathrm{True}$$\mathrm{True}$

$\mathit{bb}$$\mathit{bb}$$\mathrm{True}$$\mathrm{False}$

JavaScript (ES6), 76 байт

Повертається булевим.

ff=ss=>ss==(ss=ss.replace(/(.)\1/,''))?!ss:ff(ss)//)(:!?,/1\).(/(ecalper.=(>

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

Запропоновано @Shaggy: 58 байт , повернувши порожній рядок для ідеально з’єднаних пар або викинувши помилку в іншому випадку.

Мова Вольфрама (Mathematica) , 70 64 байт

{#//.{aa___,bb__,bb_,cc___}:>{aa,cc}}=={{}}(**(,{>:}_,{.#{&)**)&

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

Без коментарів, 92 байти

((#//.bb_:>StringReplace[00[ecalpeRgnirtS>aa__:_.#&];bb,{{,}};00>00;00;aa:_~~aa_:>""]))==""&

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

Луа , 178 байт

p=...S={}for a in p:gmatch"."do E=S[#S]~=a;S[E and#S+1 or#S]=E and a or X end;print(#S==0)--)0S#(tnirp;dne X ro a dna E=]S#ro 1+S#dna E[S;a=~]S#[S=E od"."hctamg:p ni a rof}{=S.=p

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

Незважаючи на те, що це дуже жахливе рішення, це дуже корисно для пристрастей для Луа. Це насправді алгоритм стеження грубої сили. Програма ускладнюється тим, що шаблони Lua не дозволяють замінювати пари, а регулярний вираз не вбудований.

Пояснення:

p=... -- command-line argument
S={} -- the stack
for c in p:gmatch"." do -- shorter than "for i=1,#p do ..."
    E=S[#S]~=c -- check whether we have the right letter on top of stack
    -- could've saved some bytes by doing == instead of ~=
    -- but the double negation is necessary for ternary operator
    -- to work with nil values
    S[E and #S+1 or #S]=E and c or X -- Lua's awesome "ternary operator"
end
-- i'm sure there is a better way to output this (table indexing?)
print(#S==0)

Гол> <> , 30 байт

1ll1**F:}}:{=Q{~~||lzBBzl{Q={F

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

Все після першого Bє зайвим кодом і не виконується. Функція, яка повертає верхню частину стека так, 1ніби вхід є ідеальним сполученням, 0інакше.

Пояснення:

1       Push 1 as the end string marker
 ll1**  Push n, where n (len+1)*(len+2), 
        This is larger than the amount of steps needed to determine pairing
      F           |  Repeat that many times
       :}}:{=        Compare the first two characters of the string
             Q   |   If they are equal
              {~~    Pop both of them
        String is also rotated by 1
        If the string becomes empty, the 1 is compared to itself and removed.
                   lzB   Return whether the length of the stack is 0
                      Bzl{Q={F  Excess code to match unpaired symbols

Cubix , 30 байт

1O@;??;@ii??O;>>;;;..1Wcc1??1W

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

Виводиться, 1якщо рядок ідеально поєднаний і нічого іншого.

Кубіфікований

      1 O @
      ; ? ?
      ; @ i
i ? ? O ; > > ; ; ; . .
1 W c c 1 ? ? 1 W . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Спрощений

      1 O @
      ; ? .
      . @ .
i ? . . . . > ; ; ; . .
. W c . . . ? 1 W . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Логіка та загальна структура такі ж, як у відповіді Мнемоніка, але без явної перевірки на порожній рядок.

Хаскелл , 92 байти

gg""

gg((aa:cc:bb))dd|aa==cc=gg bb dd

gg  aa""=""==aa

gg  aa((bb:c))=gg((bb:aa))c--c:=c:|

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

Відповідь @ німі досить класна, вона не використовує жодних коментарів. Цей коротший, але він використовує коментар.

@ xnor відповідь також досить класна, вона використовує коментарі і коротша за цю.

Python 2 , 114 байт

import re

e=lambda i,nn=1:e(*re.subn('(.)\\1','',i))if nn else''==i##ieslef'1).('(nbus.er*(e:1=,i adbmal=r tropmi

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

Повернення Trueдля ідеально парних рядків, в Falseіншому випадку.

(Насправді не вдається перевірити себе, тому що (.)не буде відповідати новим рядкам у коді! Але @Cat Wizard сказав, що це нормально, тому що нові рядки не друкуються символами ASCII, тому моя програма не повинна їх обробляти.)

Це ідеально поєднана версія:

import re;p=lambda s,n=1:p(*re.subn('(.)\\1','',s))if n else''==i

для якої «лазерне» вдосконалення code + '##' + f(code[::-1])дало б 120 байт. (Тобто перейменування змінних і т.д. для введення більше згорнутих пар всередині коментаря половина коду зберегла 6 байт.)

re.subn- маловідомий варіант, re.subякий повертає кортеж (new_string, number_of_substitutions_made). Це досить добре для пошуку точок фіксації заміни регулярного виразу!

Желе , 26 24 22 байт

ẠƬµF€ḂLḣgŒŒgḣLḂ$$€FµƬẠ

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

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

Повертає 0, якщо вхід ідеально спарений, 1 в іншому випадку.

Активний код:

ŒgḣLḂ$$€FµƬẠ
Œg            Group runs 'abbbcc'->['a','bbb','cc']
       €      For each of these strings:
      $       Monad{
     $            Monad{
   L                  Find the length...
    Ḃ                 ...mod 2. 
                      } -> [1, 1, 0] in this example.
  ḣ               Take this many characters from the string.
                  } -> [['a'], ['b'], []]
        F     Flatten -> ['a', 'b']
          Ƭ   Repeat...
         µ    The last monadic chain until a fixed point is reached.
           Ạ  All. If it is not a perfectly paired string, all elements in the 
              result of Ƭ will be nonempty and 1 is returned.
              If it is perfectly paired, the last element is [] which is falsy
              and 0 is returned.

Attache , 82 байти

{0=#Fixpoint[{Replace[_,/"(.)\\1",""]},_]}??}]_,}],"1).("/,_[ecalpeR{[tniopxiF#=0{

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

Нічого неймовірного тут немає. Fixpointsa функція, яка видаляє послідовні пари.

Java 8, 158 156 154 байт

n->{for(;n.matches(".*(.)\\1.*");n=n.replaceAll("(.)\\1",""));return  n.isEmpty();}//};)(ytpmEsi.ruter;,"1).("(Aecalper.n=n;)"*.1).(*."(sehctam.n;(rof{>-n

Повертає булева ( true/ false).

-2 байти завдяки @raznagul .

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

Пояснення:

n->{                              // Method with String parameter and boolean return-type
  for(;n.matches(".*(.)\\1.*");   //  Loop as long as the String still contains pairs
    n=n.replaceAll("(.)\\1","")); //   Remove all pairs
  return  n.isEmpty();}           //  Return whether the String is empty now
//};)(ytpmEsi.ruter;,"1).("(Aecalper.n=n;)"*.1).(*."(sehctam.n;(rof{>-n
                                  // Comment reversed of the source code,
                                  // minus the pairs: '\\';'ll';'\\';'""))';'n  n';'//'