Stack Cats é uma linguagem reversível baseada em pilha. Sua natureza reversível cria loops um tanto estranhos. Esse desafio é sobre o loop condicional (...)
. Quando esses loops são aninhados de certas maneiras, é possível transformar o código para reduzir a profundidade do aninhamento. Aqui estão as regras (onde A
e B
representam trechos arbitrários):
- Quando um loop começa com outro, podemos extrair o loop interno para a frente:
((A)B)
torna - se(A)(B)
. - Quando um loop termina com outro loop, podemos extrair o loop interno até o fim:
(B(A))
torna - se(B)(A)
. - Loops vazios,,
()
podem ser removidos totalmente do programa. Como corolário (em conjunto com as outras regras),((A))
é equivalente a(A)
.
Os loops única aninhados que permanecem são de forma (A(B)C)
, onde A
, B
e C
são não-vazia.
O desafio
Você recebe um programa Stack Cats válido e sua tarefa é reduzir o nível de aninhamento de loops o máximo possível, sem deixar loops vazios, usando as transformações acima.
Um programa Stack Cats válido ...
- ... consiste apenas nos personagens
()/\<>[]{}!"*+-:=ITX^_|
. - ... possui simetria espelhada (por exemplo,
\(]{}!{}[)/
é um programa válido, mas/|/
não é). - ... foi correspondido e aninhado corretamente
()
e{}
([]
,<>
e\/
não necessariamente precisa ser correspondido como de costume, embora eles apareçam em pares devido ao requisito de simetria de espelho).
Você pode usar uma sequência ou uma lista de caracteres como entrada, mas a saída precisa ser apresentada no mesmo formato.
Você pode escrever um programa ou uma função e usar qualquer um dos nossos métodos padrão de recebimento de entrada e fornecimento de saída. Observe que essas brechas são proibidas por padrão.
Isso é código-golfe , então a resposta mais curta e válida - medida em bytes - vence.
Casos de teste
Os casos de teste são duas linhas cada (entrada e saída), separadas por linhas vazias. Observe que uma saída está vazia. Você também precisa oferecer suporte à entrada vazia (o que deve resultar em saída vazia).
(((=+|+=)))
(=+|+=)
({(=+|+=)})
({(=+|+=)})
((\)/)I(\(/))
(\)(/)I(\)(/)
(()()(())()())
((<|>((X((T)))[_]))\^/(([_](((T))X))<|>))
(<|>)(X)(T)([_])(\^/)([_])(T)(X)(<|>)
(...)
loops do tipo.
\^/
entre parênteses?
(<|>((X((T)))[_]))
e (([_](((T))X))<|>)
.
((A)B(C))
, (A)(B)(C)
as regras 1 e 2 se tornarão subsequentes: ((A)B(C))
→ (A)(B(C))
(regra 1) → (A)(B)(C)
(regra 2).
()
, para que uma entrada{{A}B}
permaneça como está e não será extraída{A}{B}
também?