填写支架

18

普通括号（()，[]，<>和{}）是很好的和明确的，但有人认为这将是使用非括号字符作为括号是一个好主意。这些字符|和和"是不明确的。例如做

""""

相当于

(())

要么

()()

这是不可能的。

例如，当您混合使用类型不明确的方括号时，事情开始变得有趣起来

"|""||""|"

可能是以下任何一个

([(([]))]),([()[]()]),([()][()])

任务

您的任务是获取由歧义字符组成的字符串，并输出作者可能想要的所有可能的平衡字符串。

更具体地讲，你的输出可以做出替换所有的字符串平衡|与任一[或]并"用两种(或)。您不应两次输出任何平衡的字符串。

IO

作为输入，您应该采用由|和组成的字符串"。如果您想选择比其他两个不同的角色|，并"担任你可以这样做替代品。您应该输出一个平衡字符串的容器。您可以选择更换[]，并()在输出与任何其他两种支架对（()，[]，<>或{}）你的愿望。您的输出格式应在每次运行中保持一致。

计分

这是代码高尔夫球，因此答案将以字节计分，而字节越少越好。

测试用例

"" -> ["()"]
"|"| -> []
||| -> []
"""" -> ["(())","()()"]
""|| -> ["()[]"]
"|"||"|" -> ["([([])])"]    
"|""||""|" -> ["([(([]))])","([()[]()])","([()][()])"]
code-golf  string  balanced-string 
— 小麦巫师
source
4
等待一个BrainFlak答案
— caird coinheringaahing 18/02/2
我们可以使用整数代替字符串吗？数字或整数列表呢？
— Zgarb
@Zgarb确保没问题
— Wheat

Answers:

7

Python 2，135个字节

s=input()
for k in range(2**len(s)):
 try:c=''.join("[]() , ,"[int(c)|k>>i&1::4]for i,c in enumerate(s));eval(c);print c[::2]
 except:0

在线尝试！

期望输入像2002而不是"||"，并用引号引起来。

遍历字符串的“ open”和“ close”的所有2 N个可能的赋值，创建如下字符串c：

"( [ ( ),],[ ( ),],),( ),"

如果eval对该字符串进行-ing抛出异常，则它是不匹配的。如果没有，我们打印 c[::2]，给出：

([()][()])()
— 林恩
source
6

视网膜，59 56 55字节

0`"
<$%">
}0`'
{$%"}
.+
$&_$&
+m`^_|(<>|{})(?=.*_)

A`_

在线尝试！不幸的是，对两组匹配的括号进行测试超出了单个.NET正则表达式的适用范围，因此它节省了15个字节来进行手动检查。编辑：由于@ H.PWiz，节省了3 4个字节。说明：

0`"
<$%">

找到a "并制作该行的两个副本，一个副本带a <和一个副本带a >。一次执行"一次，以便每"行使行数加倍。

}0`'
{$%"}

同样有'，{和}。然后，不断替换，直到所有的"S和'所有副本■找被替换。

.+
$&_$&

复制括号，并用分隔_。

+m`^_|(<>|{})(?=.*_)

在重复项中，重复删除匹配的括号，直到没有括号为止，在这种情况下，请删除 _。

A`_

删除所有仍具有 _。

视网膜，74 71 70字节

0`"
<$%">
}0`'
{$%"}
Lm`^(.(?<=(?=\3)(<.*>|{.*}))(?<-3>)|(.))+(?(3)_)$

在线尝试！说明：前两个阶段如上所述。第三阶段直接打印匹配两组匹配的括号的结果。这使用.NET的平衡组。在比赛的每个阶段，正则表达式都会尝试匹配一个字符，然后回头寻找一对匹配的括号，然后检查堆栈顶部是否与开放的括号匹配。如果能够做到这一点，则意味着括号平衡，并且打开的括号从堆栈中弹出。否则，假定我们处于一个需要被推到栈中的开放式括号中。如果这些假设不成立，那么堆栈最后将不会为空，并且匹配将失败。

另一种方法，也是74 71字节：

Lm`^((?=(<.*>|{.*})(?<=(.))).|\3(?<-3>))+(?(3)_)$

在这里，我们向前看是<... >或{... }，然后往后看以将闭合括号推入堆栈。否则，我们需要匹配并弹出前面捕获的右括号。在此版本中，正则表达式甚至可能不会到达字符串的末尾，但是<<<>如果我们不检查空栈，则某些字符串（例如，某些字符串）会穿过网络。

— 尼尔
source
1
您可以使用其他字符在转义时节省一些字节
— H.PWiz
@ H.PWiz啊，关于使用其他括号对，我一定忽略了一点，谢谢！
— 尼尔
您也可以更改|输入
— H.PWiz
2

外壳，19个字节

fo¬ω`ḞoΣx½¨÷₂¨ΠmSe→

在线尝试！ 使用字符ds输入，以及相应的托架对de与st在输出中。

说明

这个想法是生成输入的所有可能的括号，并在我们反复删除相邻的括号时将那些减小到空字符串的括号保留。的¨÷₂¨是压缩字符串展开为"dest"，其被选择是因为它具有短的压缩形式，由与相邻的码点的字符对。因此，该程序等效于以下程序。

fo¬ω`ḞoΣx½"dest"ΠmSe→  Implicit input, say "ddssdd".
                 m     Map over the string:
                  Se    pair character with
                    →   its successor.
                       Result: ["de","de","st","st","de","de"]
                Π      Cartesian product: ["ddssdd","ddssde",..,"eettee"]
f                      Keep those strings that satisfy this:
                        Consider argument x = "ddsted".
   ω                    Iterate on x until fixed:
         ½"dest"         Split "dest" into two: ["de","st"]
    `Ḟ                   Thread through this list (call the element y):
        x                 Split x on occurrences of y,
      oΣ                  then concatenate.
                          This is done for both "de" and "st" in order.
                        Result is "dd".
 o¬                    Is it empty? No, so "ddsted" is not kept.
                      Result is ["destde","ddstee"], print implicitly on separate lines.
— 兹加布
source
2

佩尔56 55 53字节

包括 +1用于n

用途[为[]与{对{}

perl -nE 's%.%"#1$&,+\\$&}"^Xm.v6%eg;eval&&y/+//d+say for< $_>' <<< "[{[[{{[[{["

生成所有2 ^ N的可能性，然后使用perl eval检查类似'+ [+ {}]'的字符串是否为有效代码，如果是，则删除+并打印结果

— 吨·霍斯佩尔
source
1

干净，203个 186 179字节

?['(':l][')':t]= ?l t
?['[':l][']':t]= ?l t
?l[h:t]= ?[h:l]t
?[][]=True
?_ _=False
@['"']=[['('],[')']]
@['|']=[['['],[']']]
@[h:t]=[[p:s]\\[p]<- @[h],s<- @t]
$s=[k\\k<- @s| ?[]k]

在线尝试！

仅使用模式匹配和理解。

— 巨大
source
1

Perl，56个字节

包括+用于n

使用输入[作为输出[或]

使用输入{作为输出{或}

perl -nE '/^((.)(?{$^R.$2})(?1)*\2(?{$^R.=$2^v6}))*$(?{say$^R})^/' <<< "[{[[{{[[{["

使用perl扩展的正则表达式来匹配花括号，同时跟踪回溯过程中所做的选择。这比生成所有2 ^ N个候选对象要有效得多，因为在输入字符串途中它已经拒绝了许多不可能的赋值

— 吨·霍斯佩尔
source
0

科特林，240个 236 234字节

fold(listOf("")){r,c->r.flatMap{i->when(c){'"'->"()".map{i+it}
else->"[]".map{i+it}}}}.filter{val d=ArrayList<Char>()
it.all{fun f(c:Any)=d.size>1&&d.removeAt(0)==c
when(it){')'->f('(')
']'->f('[')
else->{d.add(0,it);1>0}}}&&d.size<1}

美化

    fold(listOf("")) {r,c ->
        r.flatMap {i-> when(c) {
            '"'-> "()".map {i+it}
            else -> "[]".map {i+it}
        }}
    }.filter {
        val d = ArrayList<Char>()
        it.all {
            fun f(c:Any)=d.size>1&&d.removeAt(0)==c
            when(it) {
                ')' -> f('(')
                ']' -> f('[')
                else -> {d.add(0,it);1>0}
            }
        } && d.size<1
    }

测试

private fun String.f(): List<String> =
fold(listOf("")){r,c->r.flatMap{i->when(c){'"'->"()".map{i+it}
else->"[]".map{i+it}}}}.filter{val d=ArrayList<Char>()
it.all{fun f(c:Any)=d.size>1&&d.removeAt(0)==c
when(it){')'->f('(')
']'->f('[')
else->{d.add(0,it);1>0}}}&&d.size<1}

data class Test(val input: String, val outputs: List<String>)

val tests = listOf(
    Test("""""""", listOf("()")),
    Test(""""|"|""", listOf()),
    Test("""|||""", listOf()),
    Test("""""""""", listOf("(())","()()")),
    Test("""""||""", listOf("()[]")),
    Test(""""|"||"|"""", listOf("([([])])")),
    Test(""""|""||""|"""", listOf("([(([]))])","([()[]()])","([()][()])"))
)

fun main(args: Array<String>) {
    for ((input, output) in tests) {
        val actual = input.f().sorted()
        val expected = output.sorted()
        if (actual != expected) {
            throw AssertionError("Wrong answer: $input -> $actual | $expected")
        }
    }

编辑

— Jrtapsell
source
0

C（gcc），315字节

j,b;B(char*S){char*s=calloc(strlen(S)+2,b=1)+1;for(j=0;S[j];b*=(S[j]<62||*--s==60)*(S[j++]-41||*--s==40))S[j]==60?*s++=60:0,S[j]<41?*s++=40:0;return*s>0&*--s<1&b;}f(S,n,k)char*S;{if(n<strlen(S))for(k=2;k--;)S[n]==46-k-k?S[n]=40+k*20,f(S,n+1),S[n]=41+k*21,f(S,-~n),S[n]=46-k-k:0;else B(S)&&puts(S);}F(int*S){f(S,0);}

在线尝试！

C（gcc），334字节（旧版本）

j,b;B(char*S){char*s=calloc(strlen(S)+2,1)+1;for(b=1,j=0;S[j];j++){if(S[j]==60)*s++=60;if(S[j]<41)*s++=40;b*=!(S[j]>61&&*--s!=60)*!(S[j]==41&&*--s!=40);}return*s>0&*--s<1&b;}f(S,n,k)char*S;{if(n>=strlen(S))return B(S)&&puts(S);for(k=0;k<2;k++)S[n]==46-k-k&&(S[n]=40+k*20,f(S,n+1),S[n]=41+k*21,f(S,-~n),S[n]=46-k-k);}F(char*S){f(S,0);}

在线尝试！

说明（旧版本）

j,b;B(char*S){                   // determine if string is balanced
 char*s=calloc(strlen(S)+2,1)+1; // array to store matching brackets
 for(b=1,j=0;S[j];j++){          // loop through string (character array)
  if(S[j]==60)*s++=60;           // 60 == '<', opening bracket
  if(S[j]<41)*s++=40;            // 40 == '(', opening bracket
  b*=!(S[j]>61&&*--s!=60)*       // 62 == '>', closing bracket
   !(S[j]==41&&*--s!=40);}       // 41 == ')', closing bracket
 return*s>0&*--s<1&b;}           // no unmatched brackets and no brackets left to match
f(S,n,k)char*S;{                 // helper function, recursively guesses brackets
 if(n>=strlen(S))                // string replaced by possible bracket layout
  return B(S)&&puts(S);          // print if balanced, return in all cases
 for(k=0;k<2;k++)                // 46 == '.', guess 40 == '(',
  S[n]==46-k-k&&(S[n]=40+k*20,   //  guess 41 == '(', restore
   f(S,n+1),S[n]=41+k*21,        // 44 == ',', guess 60 == '<',
   f(S,-~n),S[n]=46-k-k);}       //  guess 62 == '>', restore
F(char*S){f(S,0);}               // main function, call helper function

在线尝试！

— 乔纳森·弗雷奇
source
您不能使用GCC可变长度数组来摆脱calloc吗？
— Ton Hospel，
@TonHospel然后，我要么需要将数组转换为指针，要么需要引入另一个索引变量，我不知道它是否值得，因为我*s++在一些地方使用。
— 乔纳森·弗雷希
char S[n],*s=S仍然比chars*s=calloc(n,1)
— Ton Hospel
@TonHospel尽管它似乎不起作用，但我真的不知道为什么。
— 乔纳森·弗雷希
@ceilingcat谢谢。
— 乔纳森·弗雷希
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.