Supponiamo che un giorno stia scavando nella tua grande scatola di cavi e adattatori per computer inutilizzati (da USB a USB mini, da VGA a DVI, ecc.). Ci sono corde aggrovigliate dappertutto che creano un bel pasticcio, e ti chiedi se potresti semplificare le cose collegando tutte le corde insieme in un lungo filo, e poi semplicemente arrotolando.
La domanda è: è possibile collegare tutti i cavi e gli adattatori in una linea lunga come questa? Ovviamente non è sempre possibile, ad esempio se avessi solo due cavi con spine completamente diverse, non potrebbero essere collegati insieme. Ma se avessi un terzo cavo che può collegarsi a entrambi, allora potresti mettere insieme tutti i tuoi cavi.
Non ti importa di che tipo di spine si trovano alle estremità del filo all-cord. Non hanno bisogno di collegarsi l'un l'altro per formare un loop. Volete solo sapere se è possibile realizzare il filo all-cord, e se lo è, come farlo.
Sfida
Scrivi un programma o una funzione che accetta una stringa multilinea in cui ogni riga raffigura uno dei cavi che possiedi. Un cavo è costituito da uno o più trattini ( -), con una spina su entrambe le estremità. Una spina è sempre uno degli 8 caratteri ()[]{}<>.
Quindi questi sono alcuni cavi validi:
>->
(--[
}-{
<-----]
(---)
Ma questi non sono:
-->
(--
)--
[{
---
Quando si collegano i cavi, è possibile collegare insieme solo spine con lo stesso tipo di staffa.
Quindi questi sono alcuni collegamenti validi:
...---((---...
...---))---...
...---]]---...
...---{{---...
...---<<---...
E questi non sono validi:
...---()---...
...---)(---...
...---{]---...
...---{[---...
...---><---...
...--->)---...
Se tutti i cavi nell'input possono essere riorganizzati e collegati insieme in un lungo filamento, quindi emettere quel filamento allo stdout su una riga (con una nuova riga finale opzionale). Quando esistono più soluzioni, puoi sceglierne una qualsiasi da produrre. Se non è possibile creare un singolo filamento, non produrre nulla (o generare una stringa vuota con una nuova riga finale facoltativa).
Ad esempio, se l'ingresso è
[-->
{---]
>----{
l'output potrebbe essere
[-->>----{{---]
dove tutte le corde sono legate insieme.
Tuttavia, se l'input fosse
[-->
{---]
i cavi non possono essere collegati quindi non ci sarebbe uscita.
Si noti che i cavi possono essere capovolti quanto necessario per effettuare le connessioni. ad es. [-->e <--]sono effettivamente lo stesso cavo perché possono effettuare lo stesso tipo di connessioni. Alcune uscite potrebbero dipendere dal capovolgere i cavi di ingresso.
Per esempio
(-[
}--]
potrebbe avere output
(-[[--{
dove viene capovolto il secondo cavo, oppure
}--]]-)
dove viene capovolto il primo cavo.
(Si noti che in generale il lancio dell'intero output è valido perché è lo stesso del primo avvio di ogni singolo cavo.)
Le lunghezze dei cavi nell'uscita dovrebbero ovviamente corrispondere alle lunghezze dei cavi di ingresso corrispondenti. Ma i cavi possono essere riordinati e capovolti quanto vuoi per creare il filo all-cord. L'ingresso conterrà sempre almeno un cavo.
Vince il codice più breve in byte.
Casi test
Casi con uscita:
[-->
{---]
>----{
gives
[-->>----{{---]
or
[---}}----<<--]
(-[
}--]
gives
(-[[--{
or
}--]]-)
(-)
gives
(-)
[--{
gives
[--{
or
}--]
[-]
]-[
gives
[-]]-[
or
]-[[-]
[----->
)------------[
{--<
}---)
could give
[----->>--}}---))------------[
or
>--}}---))------------[[----->
or
}---))------------[[----->>--}
or
{--<<-----]]------------((---{
etc.
>-->
>->
>--->
could give
>-->>->>--->
or
>--->>-->>->
or
>->>-->>--->
or
<--<<---<<-<
etc.
(-]
]->
>-}
}-)
)-[
[-<
<-{
{-(
could give
(-]]->>-}}-))-[[-<<-{{-(
or
{-((-]]->>-}}-))-[[-<<-{
or
<-{{-((-]]->>-}}-))-[[->
etc.
Casi senza uscita:
[-->
{---]
[-]
[-]
(-]
]->
}-)
>->
>-->
]---]
[-------------------]
]-------------------[
[-----------------]
[-----------------]
{--[
]--}
