Сбалансированные тройные скобки


19

«Тройка скобок» (которую я составил для этого испытания) является одним из следующих:

(...+...)
[...:...]
{...|...}
<...-...>

Сбалансированная строка триплетных скобок (для краткости BTBS) представляет собой либо пустую строку, две сцепленные BTBS, либо одну из указанных выше тройных скобок, каждая из которых ...заменяется на BTBS.

Ваша задача - написать программу или функцию, которая проверяет, (+)[:]{|}<->сбалансирована ли строка, состоящая только из одной строки . Самый короткий код выигрывает.

Примеры

Ваша программа должна вернуть truey для следующих строк:

(+)(+)(+)
[[[:]:]:(+(+))]{<->|<(+)->[:]}(+)
<<<<<<<<<<<<->->->->->->->->->->->->
{|(+[:<-{|(+[:<->])}>])}
[[[:]:[:]]:[[:]:[:]]]
{[:](+)|<->{|}}[(+)<->:{|}(+)]

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

:[
<|>
(+(+)
[:][:](+[[:]):]
{|{|{|(+{|{|{|}}}}}+)}[:]{|}
{{||}}
<<->-<->-<->>
[(+):((+)+)+(+(+))]
<<<<<->->->->->->

Является (|)действительным. Я так не думаю, но я не уверен
Роман Гриф

@ RomanGräf Нет, как <|>в ложных примерах.
jimmy23013

Ответы:


1

Japt, 25 байт

!Ue"%(%+%)|%[:]|\{%|}|<->

Проверьте это онлайн!

eв строках - это функция рекурсивного замещения. Второй параметр по умолчанию равен пустой строке, что означает, что это рекурсивно удаляет совпадения регулярного выражения Japt "%(%+%)|%[:]|\{%|}|<->"(в обычных терминах, /\(\+\)|\[:]|{\|}|<->/). Это возвращает пустую строку для сбалансированных триплетных строк и непустую строку для несбалансированных, поэтому правильное возвращаемое значение является логическим НЕ этого.


14

JavaScript (ES6), 77 58 57 56 байт

f=s=>s==(s=s.replace(/\(\+\)|\[:]|{\|}|<->/,''))?!s:f(s)

Контрольные примеры


2
Та же идея в Retina составляет 26 байт (первая строка просто делает его тестовым набором): retina.tryitonline.net/…
Martin Ender,

1
И 39 с Perl: perl -lpe 's/<->|\(\+\)|{\|}|\[:]//&&redo;$_=!$_'.
Дада

@ Дада Это будет рассматривать 0BTBS. Вместо этого используйте 38:perl -pe 's/<->|\(\+\)|{\|}|\[:]//&&redo;$_=/^$/'
Тон Хоспел

@TonHospel Не думал об этом, на самом деле .. спасибо, что указал на это! (не стесняйтесь размещать его, если хотите, кстати, или, по крайней мере, не сдерживайтесь из-за меня)
Dada

Эта смесь S / S была немного запутанной, возможно f=s=>s==(s=s.replace(...))?!s:f(s)?
Нил

5

sed, 28 27 байтов

:
s#(+)\|\[:]\|{|}\|<->##
t

У sed нет понятия истина / ложь, поэтому я рассматриваю пустую строку как истину и непустую ложную строку. Это проверяет, если мы считаем условным /^$/.

Спасибо @Neil за игру в 1 байт!

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


1
На этот раз BRE на самом деле является преимуществом .
Деннис

Вам нужно \]или ]достаточно?
Нил

Я не. Благодарность!
Деннис

4

Python, 77 байт

lambda s:eval("s"+".replace('%s','')"*4%('(+)','[:]','{|}','<->')*len(s))==''

Использует идею замены Арно . Генерирует и оценивает длинную строку как

s.replace('(+)','').replace('[:]','').replace('{|}','').replace('<->','').replace('(+)','').replace('[:]','').replace('{|}','').replace('<->','')

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


3

Mathematica, 55 байт

StringDelete["(+)"|"[:]"|"{|}"|"<->"]~FixedPoint~#==""&

Анонимная функция. Принимает строку как ввод и возвращает Trueили Falseкак вывод. Использует стандартный метод для этого.


2

Грязь , 39 байт

e`\(_\+_\)|\[_\:_\]|\{_\|_\}|\<_\-_\>v*

Попробуйте онлайн! К сожалению, версия TIO не хватает памяти в большинстве тестовых случаев.

объяснение

Здесь нет ничего особенного. _является сокращением для всего шаблона и v*является таким же, как *, но с более низким приоритетом.

e`                                       Match entire input against this pattern:
  \(_\+_\)                               '(', match of _, '+', match of _, ')'
          |                              or
           \[_\:_\]|\{_\|_\}|\<_\-_\>    same for the other bracket types
                                     v*  repeated 0-∞ times

2

J, 48 байтов

a:=([:delstring&.>/'(+)';'[:]';'{|}';'<->';])^:_

Подобно другим, это также основано на методе Арно .

использование

   f =: a:=([:delstring&.>/'(+)';'[:]';'{|}';'<->';])^:_
   f '(+)(+)(+)'
1
   f '[[[:]:]:(+(+))]{<->|<(+)->[:]}(+)'
1
   f '<<<<<<<<<<<<->->->->->->->->->->->->'
1
   f '<|>'
0
   f '[:][:](+[[:]):]'
0
   f '{|{|{|(+{|{|{|}}}}}+)}[:]{|}'
0

объяснение

a:=([:delstring&.>/'(+)';'[:]';'{|}';'<->';])^:_  Input: string S
   (                                        )^:_  Repeat until convergence
                                         ]          Get S
                 '(+)';'[:]';'{|}';'<->';           Append to ['(+)', '[:]', '{|}', '<->']
    [:delstring&.>/                                 Reduce right-to-left by deleting
                                                    occurrences of each string on the
                                                    left from the right
                                                    Return the final string as the new S
a:=                                               Test if the final value of S is empty

0

Скала, 96 байт

def&(s:String):Any={val t=s.replaceAll(raw"\(\+\)|\[:]|\{\|}|<->","")
if(t==s)t.size<1 else&(t)}

Это в основном та же идея, что и в других ответах, но с некоторыми шаблонами scala.

без кражи идей у ​​других (188 байт):

import scala.util.parsing.combinator._
val a = new RegexParsers{def r:Parser[_]="("~r~"+"~r~")"|"["~r~":"~r~"]"|"{"~r~"|"~r~"}"|"<"~r~"-"~r~">"|""
def!(s:String)= !parseAll(r,s).isEmpty}!_

0

Пип , 26 байт

L#aaR:"(+)[:]{|}<->"<>3x!a

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

Обрабатывает len (a) раз, заменяя все вхождения пустых триплетных скобок ( "(+)[:]{|}<->"<>3где <>оператор "group" => ["(+)"; "[:]"; "{|}"; "<->"]) пустой строкой ( x). Это много итераций - излишне, но этого всегда будет более чем достаточно, чтобы полностью свести все правильно сформированные триплетные скобки к нулю. После завершения цикла выдает !a: 0if ais true (по-прежнему содержит несколько символов), 1if a- false (пусто).

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.