Створіть усі фрагменти "Мозковий-Флак"


14

Це питання є другим із декількох викликів дня народження Brain-Flak, призначених відсвяткувати перший День народження Brain-Flak! Ви можете знайти більше інформації про день народження Brain-Flak тут

Виклик

Для цього завдання ви будете генерувати всі цілком відповідні рядки зі списку дужок. Щоб запозичити визначення DJMcMayhem повністю відповідного рядка:

  • Для цього виклику, «дужка» представляє собою будь-яка з цих символів: ()[]{}<>.

  • Пара дужок вважається "зібраною", якщо дужки, що відкриваються і закриваються, є в правильному порядку і не містять символів всередині них, наприклад

    ()
    []{}
    

    Або якщо кожна субелемент всередині нього також збігається.

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

    Субелементи також можуть вкладатись у кілька шарів глибиною.

    [(){<><>[()]}<>()]
    <[{((()))}]>
    
  • Рядок вважається "Повністю узгодженим", якщо і лише в тому випадку, якщо кожна пара дужок має правильну дужку відкривання та закриття в потрібному порядку.


Вхідні дані

Ваша програма чи функція прийматиме список із чотирьох негативних чисел у будь-якому зручному та послідовному форматі. Це включає (але не обмежується цим) список цілих чисел, нерозрядний розділений рядок або окремі аргументи. Ці чотири числа представляють кількість відповідних пар кожного типу дужок. Наприклад, [1,2,3,4]буде представляти:

  • 1 пара ()

  • 2 пари {}

  • 3 пари []і

  • 4 пари <>

Ви можете вибрати, якій парі дужок відповідає кожен вхід, доки він відповідає.

Вихідні дані

Вам слід вивести всі повністю відповідні рядки, які можна сформувати із цього списку дужок без дублікатів. Вихід може бути у будь-якому розумному форматі, який включає друк рядка, не обмеженого дужками, на STDOUT або список рядків у якості зворотного значення функції.

Ваш алгоритм повинен працювати для будь-якого довільного введення, але вам не потрібно турбуватися про обмеження пам’яті, часу або цілих чисел (наприклад, якщо ваша відповідь знаходиться на С, ви не отримаєте 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]

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

Відповіді:


6

Haskell , 128 байт

fє основною функцією, вона бере список Ints і повертає список 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)

Спробуйте в Інтернеті!

Як це працює

  • fперетворює свій вхідний список у перелік списків кортежів, кожен кортеж, що містить дужку пари, з кожним типом дужок у власному підсписі. Напр. [1,2,0,0]Стає [[('{','}')],[('[',']'),('[',']')]]. Потім він дзвонить gіз перетвореним списком.
  • У решті функцій використовується стиль частково проходження продовження, змішаний зі списком маніпуляції. Кожна функція продовження cприймає список списків, що lзалишилися в дужках, і повертає список можливих рядків, який буде суфіксовано до вже створеного.
  • g lгенерує список повністю узгоджених рядків, що формуються, використовуючи всі дужки в l.
    • Це робиться за допомогою виклику l#gдля створення рядків, починаючи з деякої дужки. Рекурсивний gпараметр сам по собі використовується як продовження #, щоб генерувати те, що настає після першого підкресленого субелемента.
    • У випадку, коли таких рядків немає (оскільки в lній не залишилося дужок), gповертається [""]список, що містить лише порожній рядок. Оскільки [""]порівнюється менший з усіма порожніми списками #, які можна отримати, ми можемо це зробити, застосувавши max.
  • l#cгенерує рядки lпочинаючи з щонайменше однієї дужки з дужкою, залишаючи до продовження cдля визначення того, що слід за елементом.
    • bі eє виділеною парою дужок в кортежі x, і rє списком залишилися кортежів одного типу дужок.
    • r:filter(/=x:r)lзнаходиться lз кортежем, 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Ðḟ

Простий і неефективний.

Спробуйте в Інтернеті! (тайм-аут у TIO для [1,1,1,1] - так, неефективно.)

Як?

Рекурсивно видаляє пари відповідних дужок, які розташовуються поруч один з одним, доки більше не може бути видалено для кожного можливого рядка, який може утворюватися, зберігаючи такі рядки, які зводяться до нічого (отже, мають весь відповідний вміст).

“()“{}“[]“<>”©ẋ"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
Не потрібно використовувати трюки eval ... замість цього використовуйте зменшення. 35 байт
Leaky Nun

1
Переміщення першого рядка до другого ... 34 байти
Leaky Nun

@LeakyNun Дякую! Я намагався, але не зміг скоротити роботу (отже, вдався до використання eval).
Джонатан Аллан

Приємно, я використовував той самий підхід œṣ- F- µÐLу дещо пов'язаній проблемі .
Zacharý

3

Pyth - 83 74 71 63 байт

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

Спробуй це

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

Також ця 53-байтна версія завдяки Leaky Nun

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

Ось


Желе побитий Пітом? Що це за чаклунство?
наркоман з математики

@mathjunkie я не побив желе; Я накрутив синтаксис введення.
Марія

... і я думаю, що можу вдосконалитись: D
Джонатан Аллан

@JonathanAllan так може відповісти на це.
Leaky Nun

1
Крок 1: замість цього ("\[]""{}""\(\)""<>")робимо c"\[] \{} \(\) <>")(розділяємо на пробіли); замість цього :@Kd*\\2kми робимо -@Kdдва похилі риси; то, замість того, щоб відображати карти U4, робимо *V-R\\KQ(множимо два масиви паралельно). Перший масив генерується за допомогою R, а саме -R\\kце дасть вам 54-байтну версію
Leaky Nun,

2

05AB1E , 33 32 30 27 25 байт

Збережено 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. Це на 1 байт коротше використовувати UXна початку, і Xколи вам знову потрібен список дужок.
Райлі

@Riley: Я спробував лише :спочатку, але у нас виникають проблеми, коли, наприклад, заміна {}створює можливі заміни, ()оскільки ми вже намагалися замінити всі (). Хороший момент про UXте, хоча. Ми також можемо отримати ще один байт ©®.
Емінья

Те, що Uспливає верхівка, завжди засмучувало. Я про це не знав ©®.
Райлі

Я дивився на цю відповідь . Чи отримав 05AB1E оновлення, яке його порушило, чи ця відповідь не вірна?
Райлі

Ця відповідь працює для [([]{})<{[()<()>]}()>{}], але не для [({})<{[()<()>]}()>{}]. Єдина відмінність - вилучена []. Я про це запитую в ТНБ.
Райлі

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
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.