Genera tutti i frammenti di scaglie di cervello


14

Questa è la seconda delle numerose sfide per il compleanno di Brain-Flak progettate per celebrare il primo compleanno di Brain-Flak! Puoi trovare maggiori informazioni sul compleanno di Brain-Flak qui

Sfida

Per questa sfida genererai tutte le stringhe completamente abbinate da un elenco di parentesi. Per prendere in prestito la definizione di DJMcMayhem di una stringa completamente abbinata:

  • Ai fini di questa sfida, una "staffa" è uno di questi personaggi: ()[]{}<>.

  • Una coppia di parentesi è considerata "abbinata" se le parentesi aperta e chiusa sono nell'ordine giusto e non contengono caratteri al loro interno, come

    ()
    []{}
    

    O se anche ogni sottoelemento al suo interno è abbinato.

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

    I sottoelementi possono anche essere nidificati a più livelli di profondità.

    [(){<><>[()]}<>()]
    <[{((()))}]>
    
  • Una stringa viene considerata "Completamente abbinata" se e solo se ogni coppia di parentesi ha la parentesi aperta e chiusa corretta nell'ordine giusto.


Ingresso

Il tuo programma o funzione prenderà un elenco di quattro numeri non negativi in ​​qualsiasi formato conveniente e coerente. Ciò include (ma non si limita a) un elenco di numeri interi, una stringa delimitata da non cifre o argomenti separati. Questi quattro numeri rappresentano il numero di coppie corrispondenti di ciascun tipo di parentesi. Ad esempio, [1,2,3,4]rappresenterebbe:

  • 1 paio di ()

  • 2 coppie di {}

  • 3 coppie di []e

  • 4 coppie di <>

È possibile scegliere a quale coppia di parentesi corrisponde ciascun input purché sia ​​coerente.

Produzione

Dovresti generare tutte le stringhe completamente abbinate che possono essere formate da questo elenco di parentesi senza duplicati. L'output può essere in qualsiasi formato ragionevole che include la stampa di una stringa delimitata senza parentesi su STDOUT o un elenco di stringhe come valore di ritorno da una funzione.

L'algoritmo deve funzionare per qualsiasi input arbitrario, ma non è necessario preoccuparsi dei limiti di memoria, tempo o dimensione intera (ad es. Se la risposta è in C non si otterrà 2 33 come input).

Questo è , quindi vince la risposta più breve in byte.

Esempio di input e output

Per questo esempio userò lo stesso ordine di input di cui sopra.

Per ogni esempio, la prima riga verrà inserita e le seguenti righe saranno l'output

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]

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

Risposte:


6

Haskell , 128 byte

fè la funzione principale, prende un elenco di Ints e restituisce un elenco di 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)

Provalo online!

Come funziona

  • ftrasforma il suo elenco di input in un elenco di elenchi di tuple, ciascuna tupla contenente una coppia di parentesi quadre, con ogni tipo di parentesi nella propria lista secondaria. Ad esempio [1,2,0,0]diventa [[('{','}')],[('[',']'),('[',']')]]. Quindi chiama gcon l'elenco trasformato.
  • Le restanti funzioni utilizzano uno stile di passaggio di continuazione parzialmente mescolato con la manipolazione dell'elenco. Ogni funzione di continuazione cprende un elenco ldegli elenchi di tuple di parentesi rimanenti e restituisce un elenco di possibili stringhe da aggiungere a ciò che è già stato generato.
  • g lgenera l'elenco di stringhe con corrispondenza completa formabile utilizzando tutte le parentesi in l.
    • Lo fa chiamando l#gper generare stringhe che iniziano con qualche parentesi. Il gparametro ricorsivo viene di per sé utilizzato come continuazione di #, per generare ciò che viene dopo il primo sottoelemento tra parentesi.
    • Nel caso in cui non vi siano stringhe di questo tipo (poiché lall'interno non sono presenti parentesi) , viene grestituito [""]l'elenco contenente solo la stringa vuota. Dal momento che il [""]confronto è inferiore a tutti gli elenchi non vuoti producibili da #, possiamo farlo applicando max.
  • l#cgenera stringhe ldall'inizio con almeno un sottoelemento tra parentesi, lasciando alla continuazione cper determinare ciò che segue l'elemento.
    • be esono una coppia selezionata di parentesi nella tupla x, ed rè l'elenco delle tuple rimanenti dello stesso tipo di parentesi.
    • r:filter(/=x:r)lè lcon la tupla xrimossa, leggermente riorganizzata.
    • ?viene chiamato per generare i possibili sottoelementi tra be e. Ottiene la propria continuazione map(e:).c, che prefigura eciascuna stringa di suffisso generata da c.
    • #stesso antepone l'iniziale ba tutte le stringhe generate da ?e c.
  • l?cgenera le stringhe completamente abbinate formabili utilizzando zero o più coppie di parentesi da l, quindi parte alla sua continuazione cper gestire ciò che resta. La c lparte va direttamente csenza aggiungere alcun sottoelemento, mentre l#(?c)utilizza #per generare un sottoelemento e quindi chiamare (?c)ricorsivamente per altri possibili.

4

Gelatina , 50 40 34 byte

-6 byte grazie a Leaky Nun (riducendomi al lavoro dove non potevo)

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

Semplice e inefficiente.

Provalo online! (timeout in TIO per [1,1,1,1] - sì, inefficiente.)

Come?

Rimuove in modo ricorsivo coppie di parentesi corrispondenti che si trovano una accanto all'altra fino a quando non è possibile rimuoverne altre per ogni possibile stringa che si può formare, mantenendo tali stringhe che si riducono a nulla (quindi hanno tutto il contenuto corrispondente).

“()“{}“[]“<>”©ẋ"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
Non c'è bisogno di usare i trucchi di eval ... usa invece riduci. 35 byte
Leaky Nun,

1
Spostamento della prima riga nella seconda ... 34 byte
Leaky Nun,

@LeakyNun Grazie! Ho provato ma non sono riuscito a ridurre il lavoro (quindi ho fatto ricorso all'utilizzo di eval).
Jonathan Allan,

Bene, ho usato lo stesso approccio di œṣ- F- µÐLin un problema in qualche modo correlato .
Zacharý,

3

Pyth - 83 74 71 63 byte

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

Provalo

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

Inoltre, questa versione a 53 byte grazie a Leaky Nun

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

Qui


Jelly battuta da Pyth? Cos'è questa stregoneria?
drogato di matematica il

@mathjunkie Non ho battuto Jelly; Ho rovinato la sintassi di input.
Maria,

... e penso di poter migliorare: D
Jonathan Allan,

@JonathanAllan così può questa risposta.
Leaky Nun,

1
Step 1: invece di ("\[]""{}""\(\)""<>"), lo facciamo c"\[] \{} \(\) <>")(diviso in spazi bianchi); invece di :@Kd*\\2k, seguiamo -@Kddue barre rovesciate; quindi, invece di mappare su U4, lo facciamo *V-R\\KQ(moltipliciamo due matrici in parallelo). Il primo array viene generato usando R, ovvero -R\\kQuesto ti darà una versione a 54 byte
Leaky Nun,

2

05AB1E , 33 32 30 27 25 byte

Salvato 7 byte grazie a Riley .

L'ordine di input è [(),<>,[],{}]

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

Provalo online!

Spiegazione

ž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. Penso che :vettorializzi (puoi saltare la maggior parte del ciclo infinito). 2. È più breve di 1 byte da utilizzare UXall'inizio e Xquando è necessario nuovamente l'elenco di parentesi.
Riley,

@Riley: ho provato :prima, ma si verificano problemi quando, ad esempio, le sostituzioni {}creano possibili sostituzioni ()poiché abbiamo già provato a sostituire tutto (). Un buon punto UXperò. Possiamo ottenere anche un altro byte ©®.
Emigna,

Il fatto che si Uapra la cima è sempre stato frustrante. Non lo sapevo ©®.
Riley,

Stavo guardando questa risposta . 05AB1E ha ricevuto un aggiornamento che lo ha interrotto o questa risposta non è valida?
Riley,

Quella risposta funziona per [([]{})<{[()<()>]}()>{}], ma non per [({})<{[()<()>]}()>{}]. L'unica differenza è la rimozione []. Lo chiederò a TNB.
Riley,

2

Rubino , 123 byte

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

Provalo online! È inefficiente, tuttavia, quindi anche input come [1,2,1,1]timeout online. Tutti gli esempi elencati funzioneranno, almeno!

Spiegazione

->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
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.