生成所有Brain-Flak片段


14

这个问题是旨在庆祝Brain-Flak的第一个生日的几个Brain-flak Birthday挑战中的第二个!您可以在此处找到有关Brain-Flak诞辰的更多信息

挑战

对于这个挑战,您将从括号列表中生成所有完全匹配的字符串。借用DJMcMayhem对完全匹配的字符串定义:

  • 出于此挑战的目的,“括号”是以下任意字符:()[]{}<>

  • 如果左括号和右括号的顺序正确且其中没有字符,则将一对括号视为“匹配”

    ()
    []{}
    

    或者,如果其中的每个子元素也都匹配。

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

    子元素也可以嵌套几层深。

    [(){<><>[()]}<>()]
    <[{((()))}]>
    
  • 当且仅当每对括号中的正确开/右括号正确且顺序正确时,才将字符串视为“完全匹配”。


输入值

您的程序或函数将采用任何方便且一致的格式列出四个非负数的列表。这包括(但不限于)整数列表,非数字定界字符串或单独的参数。这四个数字代表每种类型的括号的匹配对数。例如,[1,2,3,4]将代表:

  • 1对 ()

  • 2对 {}

  • 3对[]

  • 4对 <>

您可以选择每个输入对应的一对括号,只要它们是一致的即可。

输出量

您应该输出可以从此括号列表中形成的所有完全匹配的字符串,而不重复。输出可以采用任何合理的格式,包括将非括号分隔的字符串打印到STDOUT或将字符串列表作为函数的返回值。

您的算法必须适用于任何任意输入,但是您不必担心内存,时间或整数大小限制(例如,如果答案是C,则不会得到2 33作为输入)。

这是,因此最短的答案以字节为单位。

输入和输出示例

对于这些示例,我将使用与上面相同的输入顺序。

对于每个示例,第一行将被输入,随后几行将被输出

Example 0:
[0,0,0,0]


Example 1:
[1,0,0,0]
()

Example 2:
[0,2,0,0]
{}{}
{{}}

Example 3:
[0,0,1,1]
[]<>
[<>]
<[]>
<>[]

Example 4:
[0,1,2,0]
{}[][]  {}[[]]  {[]}[]  {[][]}  {[[]]} 
[{}][]  [{}[]]  [{[]}]  []{}[]  []{[]} 
[][{}]  [][]{}  [[{}]]  [[]{}]  [[]]{}

Example 5:
[1,0,0,3]
()<><><>  ()<><<>>  ()<<>><>  ()<<><>>  ()<<<>>>  (<>)<><>  (<>)<<>>
(<><>)<>  (<><><>)  (<><<>>)  (<<>>)<>  (<<>><>)  (<<><>>)  (<<<>>>)
<()><><>  <()><<>>  <()<>><>  <()<><>>  <()<<>>>  <(<>)><>  <(<>)<>>
<(<><>)>  <(<<>>)>  <>()<><>  <>()<<>>  <>(<>)<>  <>(<><>)  <>(<<>>)
<><()><>  <><()<>>  <><(<>)>  <><>()<>  <><>(<>)  <><><()>  <><><>()
<><<()>>  <><<>()>  <><<>>()  <<()>><>  <<()><>>  <<()<>>>  <<(<>)>>
<<>()><>  <<>()<>>  <<>(<>)>  <<>>()<>  <<>>(<>)  <<>><()>  <<>><>()
<<><()>>  <<><>()>  <<><>>()  <<<()>>>  <<<>()>>  <<<>>()>  <<<>>>()

Example 6:
[1,1,1,1]

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

Answers:


6

Haskell,128个字节

f是主要函数,它接受Ints的列表并返回s的列表String

f=g.($zip"({[<"")}]>").zipWith replicate
g=max[""].(#g)
l#c=[b:s|x@(b,e):r<-l,s<-(r:filter(/=x:r)l)?(map(e:).c)]
l?c=c l++l#(?c)

在线尝试!

怎么运行的

  • f将其输入列表转换为元组列表,每个元组都包含一个括号对,每种类型的括号都位于其自己的子列表中。例如[1,2,0,0]变成[[('{','}')],[('[',']'),('[',']')]]。然后调用g转换后的列表。
  • 其余函数使用与列表操作混合的部分连续传递样式。每个延续功能c将获取l剩余的括号元组列表的列表,并返回要加到已生成内容后缀的可能字符串的列表。
  • g l 生成可通过使用中的所有方括号形成的完全匹配的字符串列表 l
    • 它通过调用l#g生成以某个括号开头的字符串来实现此目的。递归g参数本身被用作延续#,以生成第一个带括号的子元素之后的内容。
    • 如果没有这样的字符串(因为l里面没有括号),g则返回[""],列表仅包含空字符串。由于[""]与可产生的所有非空列表相比#,我们可以通过应用来实现max
  • l#cl至少一个带括号的子元素开始生成字符串,然后继续c以确定该元素之后的内容。
    • be是一个选择的一对括号中的元组x,并且r是相同括号类型的其余元组的列表。
    • r:filter(/=x:r)ll与元组x删除,稍作整理。
    • ?被调用以生成b和之间可能的子元素e。它具有自己的延续map(e:).c,该延续e是由生成的每个后缀字符串的前缀c
    • #本身会在和b生成的所有字符串中加上首字母。?c
  • l?c通过使用来自的零个或多个括号对来生成可完全匹配的字符串l,然后继续c处理剩余的内容。该c l部分直接进入c而不添加任何子元素,而l#(?c)用于#生成一个子元素,然后(?c)递归调用可能的其他子元素。

4

果冻50 40 34 字节

-6个字节,感谢Leaky Nun(在无法完成的地方减少了工作)

“()“{}“[]“<>”©ẋ"FŒ!QµW;®œṣF¥/µÐLÐḟ

简单无效率。

在线尝试!(在[1,1,1,1]的TIO超时-是的,效率低下。)

怎么样?

递归地删除彼此相邻的匹配括号对,直到不再可能为每个可能形成的字符串删除了,从而使这些字符串减少为零(因此具有所有匹配内容)。

“()“{}“[]“<>”©ẋ"FŒ!QµW;®œṣF¥/µÐLÐḟ - Main link: list: [n(), n{}, n[], n<>]
“()“{}“[]“<>”                      - literal ["()", "{}", "[]", "<>"]
             ©                     - copy to register
               "                   - zip with:
              ẋ                    -   repeat list
                F                  - flatten
                 Œ!                - all permutations (yeah, it's inefficient!)
                   Q               - de-duplicate
                    µ              - monadic chain separation
                                Ðḟ - filter discard if (non empty is truthy):
                             µÐL   -   loop until no change:
                       ®           -     recall value from register
                     W             -     wrap loop variable in a list
                      ;            -     concatenate
                           ¥/      -     reduce with last two links as a dyad:
                        œṣ         -       split left on occurrences of sublist on the right
                          F        -       flatten the result

1
无需使用评估技巧...可以使用reduce代替。35个字节
Leaky Nun

1
将第一行移至第二行... 34字节
Leaky Nun

@LeakyNun谢谢!我尝试过,但无法减少工作量(因此不得不使用eval)。
乔纳森·艾伦,

不错,我用的同样的方法œṣ- F- µÐL一个有点相关的问题
扎卡里

3

Pyth- 83 74 71 63字节

K("\[]""{}""\(\)""<>")Fd{.psm*:@Kd*\\2k@QdU4JdVldFHK=:JHk))I!Jd

尝试一下

1:Kc“ [] {}()<>”)Fd {.ps * VR \ KQJdVldFHK =:JHk))I!Jd

另外,感谢Leaky Nun,这个53字节的版本

Kc"\[] \{} \(\) <>")Fd{.ps*V-R\\KQJdVldFHK=:JHk))I!Jd

这里


果冻被Pyth打败了?这是什么法术?
数学迷

@mathjunkie我没打过果冻;我搞砸了输入语法。
玛丽亚

...而且我认为我可以改善:D
乔纳森·艾伦

@JonathanAllan所以这个答案也可以。
Leaky Nun

1
步骤1:代替("\[]""{}""\(\)""<>"),而是这样做c"\[] \{} \(\) <>")(在空白处分割);而不是:@Kd*\\2k,我们在-@Kd后面加上两个反斜杠;然后,而不是映射在上U4(我们*V-R\\KQ将两个数组并行)。第一个数组使用生成R-R\\k即将为您提供54字节的版本
Leaky Nun

2

05AB1E33 32 30 27 25字节

感谢Riley节省了7个字节。

输入顺序为 [(),<>,[],{}]

žu4äשJœJÙD[D®õ:DŠQ#]€g_Ï

在线尝试!

说明

žu                             # push the string "()<>[]{}"
  4ä                           # split in 4 parts
    ©                          # store a copy in register
     ×                         # repeat each bracket a number of times decided by input
      JœJÙ                     # get the unique permutations of the string of brackets
          D                    # duplicate
           [                   # start infinite loop
            D                  # duplicate current list of permutations
             ®õ:               # replace any instance of (), [], <>, {} 
                               # with an empty string
                DŠ             # duplicate and move down 2 places on stack
                  Q#           # if the operation didn't alter the list, exit loop
                    ]          # end loop
                     €g        # get the length of each subtring
                       _Ï      # keep only the strings in the original 
                               # list of unique permutations 
                               # that have a length of 0 in the resulting list

1.我认为:向量化(您可以跳过大多数无限循环)。2. UX在开始时和X再次需要括号列表时,使用时要短1个字节。
莱利

@Riley:我确实只是尝试过:一次,但是例如当替换已经{}创建了可能的替换时(),我们已经遇到了问题,因为我们已经尝试替换all了()。很好的一点UX。我们也可以得到另一个字节©®
Emigna

U冒顶的事实总是令人沮丧。我不知道©®
莱利

我在看这个答案。05AB1E是否获得了破坏它的更新,或者该答案无效?
莱利

该答案适用[([]{})<{[()<()>]}()>{}],但不适用于[({})<{[()<()>]}()>{}]。唯一的区别是已删除[]。我会在TNB中询问。
莱利

2

红宝石,123字节

->a{"<>{}[]()".gsub(/../){$&*a.pop}.chars.permutation.map(&:join).uniq.grep /^((\(\g<1>\)|\[\g<1>\]|\{\g<1>\}|<\g<1>>)*)$/}

在线尝试!但是,它效率低下,因此即使类似的输入[1,2,1,1]也会在线超时。至少所有列出的示例都可以使用!

说明

->a{                                        # Procedure with input a
    "<>{}[]()".gsub(/../){                  # For all pairs of brackets
                          $&*a.pop          # Pop last item in input, then repeat
                                            #   the bracket pair by that number
                                  }.chars   # Get characters
        .permutation                        # All permutations of characters
                    .map(&:join)            # For each permutation, join the chars
                                .uniq       # Get unique permutations only
            .grep /^((\(\g<1>\)|\[\g<1>\]|\{\g<1>\}|<\g<1>>)*)$/}
                                            # Only return permutations that match
                                            #   this bracket-matching regex
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.