모든 Brain-Flak 스 니펫 생성


14

이 질문은 Brain-Flak의 첫 번째 생일을 축하하기 위해 고안된 몇 가지 Brain-flak Birthday 도전 과제 중 두 번째입니다! Brain-Flak의 생일에 대한 자세한 정보는 여기 에서 찾을 수 있습니다.

도전

이 도전을 위해 대괄호 목록에서 완전히 일치하는 모든 문자열을 생성합니다. 완전히 일치하는 문자열에 대한 DJMcMayhem의 정의 를 빌리려면 :

  • 이 과제의 목적 상 "브래킷"은 다음 문자 중 하나 ()[]{}<>입니다.

  • 여는 괄호와 닫는 괄호가 올바른 순서이고 괄호 안에 문자가없는 경우 괄호 쌍은 "일치하는"것으로 간주됩니다.

    ()
    []{}
    

    또는 내부의 모든 하위 요소도 일치하는 경우

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

    하위 요소는 여러 층으로 중첩 될 수도 있습니다.

    [(){<><>[()]}<>()]
    <[{((()))}]>
    
  • 각 괄호 쌍이 올바른 순서로 올바른 열기 및 닫기 괄호가있는 경우에만 문자열이 "완전히 일치"한 것으로 간주됩니다.


입력

프로그램이나 기능은 편리하고 일관된 형식으로 음이 아닌 네 개의 숫자 목록을 가져옵니다. 여기에는 정수 목록, 숫자로 구분되지 않은 문자열 또는 별도의 인수가 포함됩니다 (단, 이에 한하지 않음). 이 4 개의 숫자는 각 유형의 대괄호에서 일치하는 쌍의 수를 나타냅니다. 예를 들어 다음 [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]

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

답변:


6

하스켈 , 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튜플 대괄호의 선택된 쌍은 xr 동일한 브래킷 형태의 잔류 튜플들의 목록이다.
    • r:filter(/=x:r)l이다 l튜플과 x제거, 약간 재 배열.
    • ?b와 사이에 가능한 하위 요소를 생성하기 위해 호출됩니다 e. 그것은 자신의 계속 얻을 수 map(e:).c접두사 e에 의해 생성 된 접미사 문자열의 각을 c.
    • #자체는 and에 b의해 생성 된 모든 문자열 앞에 이니셜 을 추가합니다 .?c
  • l?cfrom에서 0 개 이상의 대괄호 쌍을 사용하여 완전히 일치하는 문자열을 생성 한 l다음 c남은 내용을 처리 하기 위해 연속으로 남겨 둡니다 . c l부분으로 직접 이동 c하는 동안, 하위 요소를 추가하지 않고 l#(?c)사용은 #하나 개의 하위 요소를 생성하고 호출 (?c)가능한 것들 상기 재귀.

4

젤리 , 50 40 34 바이트

Leaky Nun 덕분에 -6 바이트 (내가 할 수 없었던 곳에서 작업을 축소 함)

“()“{}“[]“<>”©ẋ"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
eval 트릭을 사용할 필요가 없습니다. 대신 reduce를 사용하십시오. 35 바이트
Leaky Nun

1
첫 번째 줄을 두 번째 줄로 이동 ... 34 바이트
Leaky Nun

@LeakyNun 감사합니다! 나는 시도했지만 작업량을 줄일 수 없었습니다 (따라서 eval 사용).
Jonathan Allan

니스, 나는 동일한 접근 방식을 사용 œṣ- F- µÐL다소 관련 문제 .
Zacharý

3

피스 -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에 맞은 젤리? 이 마법은 무엇입니까?
math junkie

@mathjunkie 나는 젤리를 이길 않았다; 입력 구문을 망쳤습니다.
Maria

... 그리고 나는 향상시킬 수 있다고 생각합니다 : D
Jonathan Allan

@JonathanAllan이 답변이 가능합니다.
Leaky Nun

1
1 단계 : 대신에 ("\[]""{}""\(\)""<>"), 우리가 할 c"\[] \{} \(\) <>")(공백에 분할); 대신 에 두 개의 백 슬래시 :@Kd*\\2k-@Kd옵니다. 다음, 대신에 매핑의 U4, 우리가 할 *V-R\\KQ(병렬 곱셈 두 배열). 사용하는 첫 번째 배열이 생성 R, 즉 -R\\k이 당신에게 줄 것이다 54 바이트 버전
새는 수녀

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. UX처음과 X대괄호 목록이 필요할 때 사용 하는 것이 1 바이트 더 짧 습니다.
Riley

@ Riley : 나는 :먼저 시도 했지만, 예를 들어 교체 가 이미 교체를 시도 했을 때 {}가능한 교체를 만들 때 문제가 발생 ()합니다 (). UX그래도 좋은 지적 입니다. 우리는 또한 다른 바이트를 얻을 수 ©®있습니다.
Emigna

U정상 을 찌르는 사실 은 항상 좌절했습니다. 나는 몰랐다©® .
Riley

나는 이 답변 을보고 있었다 . 05AB1E가이 업데이트를 받았습니까? 아니면 그 대답이 유효하지 않습니까?
Riley

그 대답은 [([]{})<{[()<()>]}()>{}] 있지만 효과가 없습니다 [({})<{[()<()>]}()>{}]. 유일한 차이점은 제거 된 것 []입니다. TNB에서 물어 볼게요.
Riley

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
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.