Tạo tất cả các đoạn trích Brain-Flak


14

Câu hỏi này là câu hỏi thứ hai trong một số thử thách sinh nhật Brain-flak được thiết kế để kỷ niệm sinh nhật đầu tiên của Brain-Flak! Bạn có thể tìm thêm thông tin về Sinh nhật của Brain-Flak tại đây

Thử thách

Đối với thử thách này, bạn sẽ tạo tất cả các chuỗi khớp hoàn toàn từ danh sách dấu ngoặc. Để mượn định nghĩa của DJMcMayhem về một chuỗi hoàn toàn khớp:

  • Đối với mục đích của thử thách này, "khung" là bất kỳ ký tự nào trong số này : ()[]{}<>.

  • Một cặp ngoặc được coi là "khớp" nếu dấu ngoặc mở và đóng theo đúng thứ tự và không có ký tự bên trong chúng, chẳng hạn như

    ()
    []{}
    

    Hoặc nếu mọi phân tầng bên trong của nó cũng được khớp.

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

    Subelements cũng có thể được lồng nhiều lớp sâu.

    [(){<><>[()]}<>()]
    <[{((()))}]>
    
  • Một chuỗi được coi là "Hoàn toàn khớp" khi và chỉ khi mỗi cặp dấu ngoặc có dấu mở và đóng đúng theo thứ tự đúng.


Đầu vào

Chương trình hoặc chức năng của bạn sẽ có một danh sách bốn số không âm ở bất kỳ định dạng thuận tiện, nhất quán nào. Điều này bao gồm (nhưng không giới hạn ở) danh sách các số nguyên, chuỗi phân tách không có chữ số hoặc các đối số riêng biệt. Bốn số này biểu thị số lượng cặp khớp của từng loại dấu ngoặc. Ví dụ: [1,2,3,4]sẽ đại diện cho:

  • 1 cặp ()

  • 2 cặp {}

  • 3 cặp []

  • 4 cặp <>

Bạn có thể chọn cặp ngoặc nào cho mỗi đầu vào tương ứng miễn là nó phù hợp.

Đầu ra

Bạn nên xuất tất cả các chuỗi khớp hoàn toàn có thể được hình thành từ danh sách dấu ngoặc này mà không trùng lặp. Đầu ra có thể ở bất kỳ định dạng hợp lý nào, bao gồm in một chuỗi được phân tách bằng dấu ngoặc thành STDOUT hoặc danh sách các chuỗi dưới dạng giá trị trả về từ một hàm.

Thuật toán của bạn phải hoạt động cho mọi đầu vào tùy ý, nhưng bạn không cần phải lo lắng về giới hạn kích thước bộ nhớ, thời gian hoặc số nguyên (ví dụ: nếu câu trả lời của bạn là C, bạn sẽ không nhận được 2 33 làm đầu vào).

Đây là , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng.

Ví dụ đầu vào và đầu ra

Đối với những ví dụ này tôi sẽ sử dụng thứ tự đầu vào như trên.

Đối với mỗi ví dụ, dòng đầu tiên sẽ là đầu vào và các dòng sau sẽ là đầu ra

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]

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

Câu trả lời:


6

Haskell , 128 byte

flà hàm chính, nó lấy danh sách Ints và trả về danh sách Strings.

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)

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

  • fchuyển đổi danh sách đầu vào của nó thành một danh sách các danh sách các bộ dữ liệu, mỗi bộ chứa một cặp khung, với mỗi loại dấu ngoặc trong danh sách con của chính nó. Ví dụ [1,2,0,0]trở thành [[('{','}')],[('[',']'),('[',']')]]. Sau đó, nó gọi gvới danh sách chuyển đổi.
  • Các hàm còn lại sử dụng kiểu chuyển tiếp liên tục một phần xen kẽ với thao tác danh sách. Mỗi hàm tiếp tục clấy một danh sách lcác danh sách bộ khung còn lại và trả về một danh sách các chuỗi có thể được thêm vào sau những gì đã được tạo.
  • g ltạo danh sách các chuỗi khớp hoàn toàn có thể định dạng bằng cách sử dụng tất cả các dấu ngoặc trong l.
    • Nó thực hiện điều này bằng cách gọi l#gđể tạo chuỗi bắt đầu bằng một số dấu ngoặc. gTham số đệ quy tự nó được sử dụng như một sự tiếp nối bởi #, để tạo ra những gì xuất hiện sau phân lớp được đặt trong ngoặc đầu tiên.
    • Trong trường hợp không có các chuỗi như vậy (vì lkhông còn dấu ngoặc nào bên trong) gthay vào đó trả về [""], danh sách chỉ chứa chuỗi trống. Vì [""]so sánh nhỏ hơn với tất cả các danh sách không trống được sản xuất bởi #, chúng tôi có thể làm điều này bằng cách áp dụng max.
  • l#ctạo các chuỗi từ lđầu với ít nhất một phân lớp có dấu ngoặc, để lại phần tiếp theo cđể xác định phần tiếp theo phần tử.
    • belà một cặp dấu ngoặc được chọn trong bộ dữ liệu xrlà danh sách các bộ dữ liệu còn lại có cùng loại khung.
    • r:filter(/=x:r)llvới bộ dữ liệu được xgỡ bỏ, sắp xếp lại một chút.
    • ?được gọi để tạo ra các phần tử con có thể có giữa be. Nó được tiếp tục riêng của nó map(e:).c, tiền tố echo mỗi chuỗi hậu tố được tạo bởi c.
    • #chính nó chuẩn bị ban đầu bcho tất cả các chuỗi được tạo bởi ?c.
  • l?ctạo ra các chuỗi khớp hoàn toàn có thể định dạng bằng cách sử dụng các cặp ngoặc 0 hoặc nhiều hơn từ đó l, sau đó rời khỏi chuỗi tiếp tục cđể xử lý những gì còn sót lại. Phần c lđi trực tiếp vào cmà không cần thêm bất kỳ phần phụ nào, trong khi l#(?c)sử dụng #để tạo một phần con và sau đó gọi (?c)đệ quy cho những phần tiếp theo có thể.

4

Thạch , 50 40 34 byte

-6 byte nhờ Leaky Nun (giảm công việc khi tôi không thể)

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

Đồng bằng và không hiệu quả.

Hãy thử trực tuyến! (lần ra tại TIO cho [1,1,1,1] - có, không hiệu quả.)

Làm sao?

Loại bỏ một cách đệ quy các cặp dấu ngoặc khớp nằm ngay cạnh nhau cho đến khi không còn có thể bị xóa đối với mỗi chuỗi có thể hình thành, giữ cho các chuỗi đó giảm xuống không có gì (do đó có tất cả nội dung phù hợp).

“()“{}“[]“<>”©ẋ"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
Không cần phải sử dụng thủ đoạn tệ hại ... thay vào đó hãy sử dụng giảm. 35 byte
Leaky Nun

1
Di chuyển dòng đầu tiên sang ... 34 byte
Neak Leaky

@LeakyNun Cảm ơn! Tôi đã cố gắng nhưng không thể giảm bớt công việc (do đó đã sử dụng eval).
Jonathan Allan

Thật tuyệt, tôi đã sử dụng cách tiếp cận tương tự của œṣ- F- µÐLtrong một vấn đề có liên quan .
Zacharý

3

Pyth - 83 74 71 63 byte

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

Thử nó

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

Ngoài ra, phiên bản 53 byte này nhờ Leaky Nun

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

Đây


Thạch bị đánh bởi Pyth? Đây là yêu thuật gì?
nghiện toán học

@mathjunkie Tôi không đánh bại Jelly; Tôi vặn vẹo cú pháp đầu vào.
Maria

... và tôi nghĩ rằng tôi có thể cải thiện: D
Jonathan Allan

@Jonathan ALLan vì vậy có thể trả lời này.
Nữ tu bị rò rỉ

1
Bước 1: thay vì ("\[]""{}""\(\)""<>"), chúng tôi làm c"\[] \{} \(\) <>")(phân chia trên khoảng trắng); thay vì :@Kd*\\2k, chúng tôi làm -@Kdtheo sau hai dấu gạch chéo ngược; sau đó, thay vì ánh xạ trên U4, chúng tôi làm *V-R\\KQ(nhân hai mảng song song). Mảng đầu tiên được tạo bằng cách sử dụng R, cụ thể là -R\\kĐiều này sẽ cung cấp cho bạn phiên bản 54 byte
Leaky Nun

2

05AB1E , 33 32 30 27 25 byte

Đã lưu 7 byte nhờ Riley .

Thứ tự đầu vào là [(),<>,[],{}]

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

Hãy thử trực tuyến!

Giải trình

ž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. Tôi nghĩ :vector hóa (bạn có thể bỏ qua hầu hết các vòng lặp vô hạn). 2. Nó ngắn hơn 1 byte để sử dụng UXở đầu và Xkhi bạn cần lại danh sách dấu ngoặc.
Riley

@Riley: Tôi đã thử chỉ :trước tiên, nhưng chúng tôi gặp sự cố khi ví dụ thay thế trên {}tạo các thay thế có thể trên ()vì chúng tôi đã cố gắng thay thế tất cả (). Điểm tốt về UXmặc dù. Chúng ta có thể nhận được một byte khác ©®là tốt.
Emigna

Thực tế là Upops hàng đầu luôn luôn bực bội. Tôi không biết về ©®.
Riley

Tôi đã nhìn vào câu trả lời này . 05AB1E có nhận được bản cập nhật đã phá vỡ nó không, hoặc câu trả lời đó không hợp lệ?
Riley

Câu trả lời đó hoạt động cho [([]{})<{[()<()>]}()>{}], nhưng không phải cho [({})<{[()<()>]}()>{}]. Sự khác biệt duy nhất là loại bỏ []. Tôi sẽ hỏi về nó trong TNB.
Riley

2

Ruby , 123 byte

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

Hãy thử trực tuyến! Tuy nhiên, nó không hiệu quả, do đó, ngay cả các đầu vào như [1,2,1,1]sẽ hết thời gian trực tuyến. Tất cả các ví dụ được liệt kê sẽ hoạt động, ít nhất!

Giải trình

->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
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.