Определить идеальные пары

25

Давайте возьмем функцию f которая берет строку и удаляет все пары смежных одинаковых символов. Например

f(abbbacc)=aba

Обратите внимание, что когда две пары перекрываются, мы удаляем только одну из них.

Мы будем называть строку идеально спаренной, если повторное приложение в конечном итоге даст пустую строку. Например, строка выше не идеально спарена, потому что если мы снова применим мы все равно получим . Однако такая строка, как , идеально спарена, потому что если мы применяем три раза, мы получаем пустую строкуf a b a e a b b c c a d d e fabbbaccfabaeabbccaddef

f(eabbccadde)=eaae

f(eaae)=ee

f(ee)=


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

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

Это вопрос поэтому ответы будут оцениваться по размеру в байтах их источника с меньшим количеством байтов, которые будут лучше.


Тестовые случаи

abbbaccFalseabcbaFalseababFalseabbbaabaccTrueeabbccaddeTruebbbbTrue

Мастер пшеницы
источник
1
Хотя это может быть слишком поздно, чтобы изменить это сейчас, я чувствую, что «поворотная» часть задачи становится почти бессмысленной, если вы разрешаете комментарии или подобный «мертвый» код.
Geobits
11
@ Geobits я не согласен. Во-первых, я думаю, что запрет мертвого кода - это просто смутные определения, и в любом случае это никогда не будет забавным. Для двоих я думаю, что разрешение комментариев понижает планку входа. Для трех я считаю, что код без комментариев неизбежно будет лучше оценен, чем код с полным комментарием. Может быть, поворот не веселый, но было бы определенно менее весело, если бы я добавил невыполнимые ограничения, чтобы заставить ответы делать это определенным образом.
Пшеничный волшебник
4
Унар не волнует ваше правило ограничения источника, мвахахахаха (то есть ... пока ответ имеет четное число байтов).
Арнаулд
2
@Geobits Одна вещь, которая могла бы побудить к более творческим ответам, - это указать количество шагов, чтобы добраться до пустой строки в выигрыше. Использование комментариев имеет тенденцию приводить к тому, что это число будет довольно высоким, потому что комментарии естественным образом вкладываются туда, где в качестве более низкого балла требуется, чтобы вы чересчур чередовали пары. Очевидно, что уже слишком поздно что-либо менять.
Пшеничный волшебник
1
@dylnan Пустая строка может быть, зацикливаясь навсегда, однако это недопустимый вывод.
Пшеничный волшебник

Ответы:

10

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 Wizard

Ними
источник
2
Это наименьший Haskell, похожий на Haskell, который я когда-либо видел
Cubic
5

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

-2 байта благодаря овс . Выводит 0, если строка идеально согласована, 1 в противном случае.

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

Попробуйте онлайн!

ΔγʒgÉ} JJ} ĀqqĀÉgʒγΔ - Полная программа.
Δ} - до тех пор, пока результат больше не изменится:
 γʒ} - разбить строку на куски одинаковых символов и отфильтровать по:
   gÉ - длина нечетная?
      JJ - И после фильтрации соедините части вместе, но сделайте это
                     дважды, чтобы сохранить 2 байта, как в предыдущих версиях.
         Check - Проверить, является ли результат пустым
          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.
Мистер Xcoder
источник
5

Cubix , 54 байта

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

Ничего не выводится, если строка идеально спарена и в 1противном случае.
Попробуй здесь

Cubified

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

объяснение

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

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

Это можно разбить на три этапа:

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

источник
4

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
DJMcMayhem
источник
Вы могли бы заменить ^$с .и возвращать 0 для truthy, что - нибудь еще для falsy? Я немного запутался в правилах после того, как не сделал это некоторое время.
nmjcman101
Я думаю, что это сработает, за исключением того, что в правилах сказано, что вы можете вывести два разных значения: одно для случая, когда вход идеально спарен, а другое - для другого. , Это дает мне представление, хотя ...
DJMcMayhem
3

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

Оригинал:

Попробуйте онлайн!

Функция рекурсивного детектора с последующим комментарием со всеми символами в функции в обратном порядке.

НГМ
источник
Ваш код в настоящее время выдает ошибку. Вот рабочая версия на 142 байта.
Ов
Спасибо. Должно быть, это был несчастный случай.
НГМ
126 байт - возможно, вы также сможете сжать комментарий еще ...
Джузеппе
Мне интересно, будет ли `\\ ˋ упрощаться или его нужно будет дублировать в комментариях.
JayCe
@JayCe, вы могли бы подумать, что это не должно быть в комментариях, но попробуйте это, и это не похоже на работу. Я не знаю почему.
НГМ
2

Brain-Flak , 228 200 байт

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

Попробуйте онлайн!

Это немного доказательство концепции. Это может быть короче. Однако он не использует никаких комментариев.

Выводится, 0,0если вход идеально спарен, а 0,1если нет.

Мастер пшеницы
источник
2

sed 4.2.2 , 34 байта

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

Попробуйте онлайн!

Парные строки дают пустой вывод, непарные дают ct:

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

(обратите внимание, что ;это разделитель операторов)

: объявляет пустой ярлык

:t объявляет этикетку t

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

  • матч ((..??\??))\1

    • . любой персонаж
    • .?? сопровождаемый необязательным дополнительным символом
    • \?? и необязательный ?
    • затем то же самое прямо рядом с ним
  • с ничем

Теперь эта замена в паре с самим собой, так что ;до и после нее тоже отменяются

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

/..?/if .(подстановочный знак), за которым .?следует необязательный символ

  • cc изменить буфер на c
Kritixi Lithos
источник
2

Brain-Flak , 112 110 108 байт

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

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

Попробуйте онлайн!

Это основано на моем ответе от Соответствия скобок? ,

Пытался не использовать комментарии, но застрял, пытаясь собрать {}пару pop nilads ( ). Проблема заключается в том, что проще всего объединить пару скобок в другую пару того же типа. В то время как это легко для других nilads, {...}монада создает петли. Чтобы выйти из цикла, вы должны нажать 0, но как только вы выйдете из цикла, вам нужно будет вытолкнуть 0, что усугубляет проблему.

66-байтовое готовое решение:

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

Попробуйте онлайн!

Выходы 1или 1,0если вход идеальное сопряжение, 0,0если нет.

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

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

Попробуйте онлайн!

Как указал Cat Wizard, первый ответ не работает для всех переводчиков, так как не все обрабатывают #комментарии. Эта версия не содержит комментариев.

Джо Кинг
источник
Обратите внимание, что это работает только в интерпретаторе ruby ​​brainflak и, следовательно, не является чисто ответом brainflak
Wheat Wizard
@ CatWizard Есть ли канонический интерпретатор Brain-Flak? Насколько я знаю, Rain-Flak (Ruby) - оригинальный переводчик. (Также я работаю над решением без комментариев)
Джо Кинг,
На самом деле, нет. Rain-Flak - оригинальный интерпретатор, но синтаксис комментариев для него уникален. Некоторое время назад мы написали стандарт Brain-Flak, я не помню, где он закончился.
Пшеничный волшебник
@CatWizard Закончена версия без комментариев
Джо Кинг,
2

Japt, 24 22 байта

Выходы falseдля правды и trueфальсея.

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

Попытайся

мохнатый
источник
Будет «e"(.)%1работать?
Оливер
@ Оливер, это то, что у меня изначально было до того, как ограничения источника были доведены до моего внимания. Все еще пытаюсь найти способ заставить это работать «, все же.
лохматый
@ Оливер, к сожалению, это не работает .
лохматый
Я подозреваю, что вы, возможно, пропустили часть задания с ограниченным исходным / исходным макетом , @Oliver.
Лохматый
Я сделал ... мой плохой.
Оливер
2

Добавить ++ , 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командами была исправлена во время разработки этого ответа.

Как это работает

Код начинается с определения двух ключевых функций, ее а также г, Эти две функции используются для вычисления следующего шага в процессе удаления пар и работают полностью изее т.е. только ее вызывается из основной программы, никогда г, Если мы определим входную строку какS, ее(S) модифицирует S следующим образом:

Во-первых, идентичные соседние символы в Sсгруппированы вместе. Для примераaбббaaбaссэто дает массив [[a],[ббб],[aa],[б],[a],[сс]], Над каждым из подсписков (т.е. одинаковыми группами) мы запускаем функциюги замените подсписки на результат функции.

гначинается с распаковки группы, размещения символов в стеке. Затем он помещает количество символов в стек и принимает абсолютную разницу с2и этот номер. Мы назовем эту разницуИкс, Давайте посмотрим, как это преобразует соответствующие входы[a], [бб] а также [ссс]:

[a][a,1]
[бб][б,б,0]
[ссc][c,c,c,1]

As you can see x indicates how many of the next character we wish to keep. For simple pairs, we remove them entirely (yielding 0 of the next character), for lone characters we leave them untouched, or yield 1 of them, and for groups where x>2, we want x2 of the character. In order to generate x of the character, we repeat the character with *, and the function naturally returns the top element of the stack: the repeated string.

After g(s) has been mapped over each group s, we splat the array to the stack to get each individual result with BF. Finally, the ^ flag at the function definition (D,ff,@^^,) tells the return function to concatenate the strings in the stack and return them as a single string. For pairs, which yielded the empty string from g, this essentially removes them, as the empty string concatenated with any string r results in r. Anything after the two ;; is a comment, and is thus ignored.

The first two lines define the two functions, ff and g, but don't execute ff just yet. We then take input and store it in the first of our 4 variables. Those variables are:

  • xx : The initial input and previous result of applying ff
  • yy : The current result of applying ff
  • aa : The loop condition
  • bb : Whether yy is truthy

As you can see, all variables and functions (aside from g) have two letter names, which allows them to be removed from the source code fairly quickly, rather than having a comment with a significant amount of xyab. g doesn't do this for one main reason:

If an operator, such as , is run over a user defined function abc, the function name needs to be enclosed in {...}, so that the entire name is taken by the operator. If however, the name is a single character, such as g, the {...} can be omitted. In this case, if the function name was gg, the code for ff and g would have to change to

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

which is 4 bytes longer.

An important term to introduce now is the active variable. All commands except assignment assign their new value to the active variable and if the active variable is being operated on, it can be omitted from function arguments. For example, if the active variable is x=5, then we can set x=15 by

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

The active variable is x by default, but that can be changed with the ` command. When changing the active variable, it is important to note that the new active variable doesn't have to exist beforehand, and is automatically assigned as 0.

So, after defining ff and g, we assign the input to xx with xx:?. We then need to manipulate our loop conditions ever so slightly. First, we want to make sure that we enter the while loop, unless xx is empty. Therefore, we assign a truthy value to aa with aa:1, the shortest such value being 1. We then assign the truthiness of xx to bb with the two lines

`bb
Bxx

Which first makes bb the active variable, then runs the boolean command on xx. The respective choices of aa:=1 and bb:=¬¬xx matter, as will be shown later on.

Then we enter our while loop:

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

A while loop is a construct in Add++: it operates directly on code, rather than variables. Constructs take a series of code statements, separated with , which they operate on. While and if statements also take a condition directly before the first , which consist of a single valid statement, such as an infix command with variables. One thing to note: the active variable cannot be omitted from the condition.

The while loop here consists of the condition aa*bb. This means to loop while both aa and bb are truthy. The body of the code first makes yy the active variable, in order to store the result of ff(x). This is done with

`yy,$ff>xx

We then activate our loop condition aa. We have two conditions for continued looping:

  • 1) The new value doesn't equal the old value (loop while unique)
  • 2) The new value isn't the empty string

One of Add++'s biggest drawbacks is the lack of compound statements, which necessitates having a second loop variable. We assign our two variables:

aa:=xxyy
bb:=¬¬(yy)

With the code

`aa,xx|yy,`bb,Byy

Where | is the inequality operator, and B converts to boolean. We then update the xx variable to be the yy variable with xx:yy, in preperation for the next loop.

This while loop eventually reduces the input into one of two states: the empty string or a constant string, even when applied to ff. When this happens, either aa or bb result in False, breaking out of the loop.

After the loop is broken, it can break for one of two reasons, as stated above. We then output the value of aa. If the loop was broken due to x=y, then both the output and aa are False. If the loop was broken because yy was equal to the empty string, then bb is falsy and aa and the output are truthy.

We then reach our final statement:

O

The program can now be in one of three states, in all of which the active variable is bb:

  • 1) The input was empty. In this case, the loop didn't run, aa=1 and bb=False. The correct output is False.
  • 2) The input was perfectly balanced. If so, the loop ran, aa=True and bb=False. The correct output is False
  • 3) The input was not perfectly balanced. If so, the loop ran, aa=False and bb=True. The correct output is True

As you can see, bb is equal to the expected output (albeit reversed from the logical answer), so we simply output it. The final bytes that help us beat Java come from the fact that bb is the active variable, so can be omitted from the argument, leaving us to output either True or False, depending on whether the input is perfectly balanced or not.

Community
источник
1

JavaScript (ES6), 76 bytes

Returns a boolean.

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

Try it online!

Suggested by @Shaggy: 58 bytes by returning an empty string for perfectly paired or throwing an error otherwise.

Arnauld
источник
1
If one of the "return values" can be an error (waiting for confirmation on that) then this could be 66 bytes.
Shaggy
Programs can by default output via exit code. In this answer's particular case, the possible outputs would be exit code 0 for perfectly paired strings and exit code 1 for non-perfectly paired strings, which are two distinct values therefore fulfilling the criteria; so the 58 byter must be perfectly valid.
Mr. Xcoder
1

Lua, 178 bytes

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

Try it online!

While it is a terribly long solution, this does make quite a bit of use of Lua-specific quirks. This is actually a minified brute force stack algorithm. The program is made complicated by the fact that Lua's patterns don't allow replacing pairs and regex is not built in.

Explanation:

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)
PhilipRoman
источник
1

Gol><>, 30 bytes

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

Try it online!

Everything after the first B is excess code and is not executed. A function that returns the top of stack as 1 if the input is a perfect pairing, 0 otherwise.

Explanation:

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
Jo King
источник
1

Cubix, 30 bytes

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

Try it online!

Outputs 1 if the string is perfectly paired and nothing otherwise.

Cubified

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

Simplified

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

The logic and general structure are the same as in Mnemonic's answer, but without an explicit check for the empty string.

Nitrodon
источник
1

Haskell, 92 bytes

gg""

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

gg  aa""=""==aa

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

Try it online!

@nimi's answer is pretty cool, it doesn't use any comments. This one is shorter but does use a comment.

@xnor's answer is also pretty cool, it does use comments and is shorter than this one.

Wheat Wizard
источник
0

Python 2, 114 bytes

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

Try it online!

Returns True for perfectly-paired strings, False otherwise.

(Actually fails to verify itself, because (.) won't match the newlines in the code! But @Cat Wizard said this is okay, because newlines aren't printable ASCII characters, so my program needn't handle them.)


This is a perfectly-paired version of:

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

for which a “lazier” perfectization of code + '##' + f(code[::-1]) would give 120 bytes. (That is, renaming the variables etc. to introduce more collapsed pairs inside the comment half of the code saved 6 bytes.)


re.subn is a little-known variant of re.sub that returns a tuple (new_string, number_of_substitutions_made). It's pretty good for finding regex substitution fixpoints!

Lynn
источник
0

Jelly, 26 24 22 bytes

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

Try it online!

Weirdly seems to work without moving the backwards code to an unused link.

Returns 0 if the input is perfectly paired, 1 otherwise.

Active code:

Œ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.
dylnan
источник
0

Attache, 82 bytes

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

Try it online!

Nothing incredible here. Fixpoints a function which removes consecutive pairs.

Conor O'Brien
источник
0

Java 8, 158 156 154 bytes

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

Returns a boolean (true/false).

-2 bytes thanks to @raznagul.

Try it online.

Explanation:

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';'//'
Kevin Cruijssen
источник
1
By renaming s to n and adding a second space to return s.isEmpty you can remove s n from the comment, saving 2 bytes in total.
raznagul