Kurung triplet seimbang

19

"Braket triplet" (yang saya buat untuk tantangan ini) adalah salah satu dari yang berikut:

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

String braket triplet seimbang (singkatnya BTBS) adalah string kosong, dua BTBS bersambung, atau salah satu dari braket triplet di atas yang masing-masing ...diganti dengan BTBS.

Tugas Anda adalah menulis program atau fungsi yang memeriksa apakah string yang hanya terdiri dari (+)[:]{|}<->seimbang. Kode terpendek menang.

Contohnya

Program Anda harus mengembalikan kebenaran untuk string berikut:

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

Program Anda harus mengembalikan falsy untuk string berikut:

:[
<|>
(+(+)
[:][:](+[[:]):]
{|{|{|(+{|{|{|}}}}}+)}[:]{|}
{{||}}
<<->-<->-<->>
[(+):((+)+)+(+(+))]
<<<<<->->->->->->
jimmy23013
sumber
Apakah (|)valid. Saya rasa tidak, tapi saya tidak yakin
Roman Gräf
@ RomanGräf Tidak, seperti <|>pada contoh-contoh palsu.
jimmy23013

Jawaban:

1

Japt, 25 byte

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

Uji secara online!

eon strings adalah fungsi rekursif-ganti. Parameter kedua default ke string kosong, yang berarti ini secara rekursif menghapus kecocokan dari regex Japt "%(%+%)|%[:]|\{%|}|<->"(dalam istilah biasa, /\(\+\)|\[:]|{\|}|<->/). Ini mengembalikan string kosong untuk string triplet seimbang dan string non-kosong untuk non-seimbang, sehingga nilai pengembalian yang benar adalah BUKAN logis dari ini.

Produksi ETH
sumber
14

JavaScript (ES6), 77 58 57 56 byte

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

Uji kasus

Arnauld
sumber
2
Gagasan yang sama di Retina adalah 26 byte (baris pertama hanya menjadikannya suite uji): retina.tryitonline.net/…
Martin Ender
1
Dan 39 dengan perl: perl -lpe 's/<->|\(\+\)|{\|}|\[:]//&&redo;$_=!$_'.
Dada
@Dada Itu akan mempertimbangkan 0BTBS. Gunakan 38 ini sebagai gantinya:perl -pe 's/<->|\(\+\)|{\|}|\[:]//&&redo;$_=/^$/'
Ton Hospel
@TonHospel Tidak memikirkan hal itu, sungguh .. terima kasih telah menunjukkannya! (jangan ragu untuk mempostingnya jika Anda mau, atau setidaknya jangan menahan diri karena saya)
Dada
Campuran S / s itu agak membingungkan, mungkin f=s=>s==(s=s.replace(...))?!s:f(s)?
Neil
5

sed, 28 27 byte

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

sed tidak memiliki konsep truthy / falsy, jadi saya mempertimbangkan string kosong truthy dan string non-empty falsy. Ini memeriksa jika kita mempertimbangkan persyaratan /^$/.

Terima kasih kepada @Neil untuk bermain golf 1 byte!

Cobalah online!

Dennis
sumber
1
Untuk sekali, BRE sebenarnya merupakan keuntungan .
Dennis
Apakah Anda memerlukan \]atau tidak ]cukup?
Neil
Bukan saya. Terima kasih!
Dennis
4

Python, 77 byte

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

Menggunakan ide pengganti Arnauld . Menghasilkan dan mengevaluasi string panjang seperti

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

untuk siklus antara mengganti semua jenis braket. Kemudian, periksa apakah hasilnya adalah string kosong.

Tidak
sumber
3

Mathematica, 55 byte

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

Fungsi anonim. Mengambil string sebagai input dan mengembalikan Trueatau Falsesebagai output. Menggunakan metode standar untuk melakukan ini.

LegionMammal978
sumber
2

Grime , 39 byte

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

Cobalah online! Sayangnya, versi TIO kehabisan memori pada sebagian besar kasus uji.

Penjelasan

Tidak ada yang terlalu mewah di sini. _adalah singkatan untuk seluruh pola, dan v*sama dengan *, tetapi dengan prioritas lebih rendah.

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

J, 48 byte

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

Mirip dengan yang lain, ini juga didasarkan pada metode Arnauld .

Pemakaian

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

Penjelasan

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
mil
sumber
0

Scala, 96 byte

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

Ini pada dasarnya ide yang sama dengan jawaban yang lain, tetapi dengan beberapa scala boilerplate.

tanpa mencuri ide dari orang lain (188 byte):

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}!_
corvus_192
sumber
0

Pip , 26 byte

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

Cobalah online!

Loops len (a) kali, menggantikan semua kemunculan kurung triplet kosong ( "(+)[:]{|}<->"<>3, di mana <>operator "grup", => ["(+)"; "[:]"; "{|}"; "<->"]) dengan string kosong ( x). Banyak iterasi ini berlebihan, tetapi akan selalu lebih dari cukup untuk sepenuhnya mengurangi semua kurung triplet yang terbentuk dengan benar menjadi nol. Setelah loop selesai, output !a: 0jika abenar (masih memiliki beberapa karakter), 1jika afalsey (kosong).

DLosc
sumber